Здравейте, нямам си и понятие от програмируеми логики, та искам да помоля да ми обясните накратко какви са разликите помежду отделните типове. Знам че са няколко вида - PAL, GAL, FPGA, PGA, CPLD, но нищо повече.

Разликите са много, но се абстрахирай от названията - те са предимно търговски и/или фирменни номера

PAL - Programmable Array Logic
GAL - Gate Array Logic
PLD - Programmable Logic Device
CPLD - Complex PLD
PGA - Programmable Gate Array
FPGA - Flex PGA

Общо взето еволюцията им е в тази посока, а инъче трябва да почетеш малко
за всеки от типовете.

Някой по - компетентен колега може да каже повече.

И аз съм безхаберен колега ,това което май е спирачка да се почопли човек е,че програматори са все фабрични... Ако някой знае за самоделки,моля да обади .

Незнам колко съм компетентен, но:

Ползват се главно FPGA и CPLD.
Основната разлика между тях е че паметта на FPGA е енерго зависима (демек ако спре тока си губят дизайна който си заложил) докато CPLD са с енегронезависима памет.
За презареждане на FPGA може да се ползва JTAG или цяло CPLD.

Е ако се беше "почоплил" малко щеше да установиш, че повечето логики се програмират без проблем със самоделки. Софтуера до голама степен също е free, а каквото не е - си има хапче.

Виж ако си кажеш, че те мързи да почетеш на английски - ще те разбера напълно.

Здравейте,

не знам дали е тука мястото, но искам да попитам дали има такова нещо като дизасемблиране на FPGA код, или както там се нарича. Аз съм програмирал само на по-високо ниво от асм нагоре и за това не знам дали правилно се изразявам... Имам един bin (пак?), който май се мята в паметта на едно FPGA и се чудя дали може да се преведе в по "четим" вид...

Благодаря

мммм би могло .
Няма никакъв пробелм с логиките, стига да имаш понятие от цифрова схемотхника. Най-елементарния начин да работш с тях е като просто рисуваш схемата. Друг вариант е като ползваш диаграми, по интелигентния начин е език за описание VHDL или Verilog каквото си харесаш. Има особенности, конкуренция на сигналите, само опроводяване, но това го има и при бързите цифрови схеми.

този BIN е все едно да гледаш асемблер код генериран от С компилатор
имаше някъде транслатор от такъв код до abel но отново ще видиш какво е синтезирано на ниско ниво но не и сорса на HDL

това важи по-скоро за jedec формата. за прости чипове (GAL/PAL) става да се транслира. за CPLD ми се вижда мъчна работа.
за битстийм за FPGA си отива към медицински случай.

каква е целта на упражнението?
ако е образователна, има доста и добри книги за това как да пишеш на VHDL.

Значи, преди да започнеш с програмируемата логика първо научи разликата между комбинаторна логика и логика с памет - без това нищо не става

Относно PAL/GAL - това може да го пропуснеш. Исторически, първо са създадени многофункционалните интегрални схеми, при които също можеш да имаш "програмиране" на функциите като вързваш определени входове към маса/захранване. После са измислили PAL/GAL при които няма нужда от излишни пинове и може да опишеш определена комбинаторна логика за част от крачетата. Като самото програмиране може да става по различни начини, но тава са подробности - не мисля че днешно време си заслужава да се използват тия екзотики - никаква функционалност, а и цената им е като за антики.

Сега за по-съвременните матрички... Устройството им се базира на еднотипни блокове, някои производители ги наричат "макроклетки" други "юнити", "блокове" - имена всякакакви. Един такъв блок ако се ползва като комбинаторна логика може да опише функция на 1-2 изхода от множество входове (16 и нагоре).
Входове на блока може да са пинове или сигнали от т.н. global routing table, съответно изходите може да се изкарат на пин или да се върнат в рутинг тейбъла.
Всяко блокче има поне 1 бит памет, които може да се ползва като различен вид синхронен/асинхронен тригер.
Обикновено изхода на блока се взема или от тригера или от комбинаторната логика, като тригера винаги се управлява от комбинаторната логика.
Нещата много варират от производител на производител, аз обеснявам грубо само идеята за "блокчето" иначе може да погледнеш дейташийта на коя да е матричка и ще видиш как изглежда едно конкретно блокче.

Програмирането на блокчето (макроклетката) както и връзките между тях може да е енергонезависимо (flash/rom) а може да е RAM базирано. В единия случай матричката помни какво си я програмирал, в другия случай винаги я програмираш.

Сега по CPLD обикновено се разбира flash матричка която има десетки или стотици макроклетки. В повечето броят на макроклетките е кратен на броя на пиновете. Най-малките имат примерно 32 макроклетки и 32 пина. Естествено всеки пин може да е вход и съответно да участва във функцията на коя да е макроклетка. За да е изход обаче един пин, му трябва една клетка която да го описва плюс евентуално ако управляваш 3-то състояние или посока още една клетка, ако е тригер със специален клок - още една макроклетка. Както се сещаш при матричка с 32 клетки трудно се правят 32 изхода, затова най-често се ползват матрички с поне 2 макроклетки на пин. Това е относително тъй като можеш всички клетки да ги навършеш и само на един пин ако искаш (примерно шифтер с паралелно зареждане).

Под FPGA пък обикновено се разбира RAM-базирана матричка с мноооого клетки. Най-най-малките са няколкостотин, средно са хиляди, големите до по няколко милиона. За да придобиеш още по-добра представа какво е една клетка ще дам пример - един 32-битов процесор като NIOS (правен специално за FPGA) заема 900 макроклетки.

Сега как се работи си матрички. Може да работиш на схемно ниво - да си чертаеш схеми логически елементи, тригери и т.н. По тоя начин далеко няма да стигнеш
Страшно неудобно е да се работи със схема - става само за начинаещи.

Второто ниво са езици от сорта на ABEL. Това е малко по-удобен начин, в смисъл че лесно се търси/променя, по-нагледен е, но по същество не се различава кой знае колко от използване на схема. Макар да е по-добре от схема, по трудност бих го сравнил с асемблер, само дето няма никакви предимства и нищо не става по-бързо. Изключително неудобство е че всеки производител има не просто собствен език ами версия на езика за всяка матричка която произвежда. Код който си го написал за един чип не тръгва на друг. Абе с две думи изобщо не са стока тия езици.

И вече новото поколение езици са VHDL и Verilog - качествено ново изразно средство. Първо са универсални, второ работиш на високо ниво - логика се описва не само като схема както е при чертежите и ABEL-ите ами и като принцип на работа. Бих казал това е единственият начин да се работи с програмируема логика


Относно "дизасемблирането" - от бин-файла може да изкараш нещо като схема. За малка матричка може и да може да усмислиш тая схема. За FPGA е просто безсмилено... Значи аз собствените си сорс файлове след няколко месеца ги гледам като теле железница, при все че коментарите са ми толкова колкото и кода.
Едно от най-големите предимства на VHDL/Verilog е че описваш нещата логически, а не както те работят или както те са свързани. Ако един С програмист обикновено има представа до какъв асемблер ще бъде компилиран кода му, то един VHDL програмист има само някаква груба идея какво ще се получи. Точно това е магията на VHDL, че може да нямаш НИКАКВА идея до какъв хардуер или каква схема ще се сведе това което си написал
Връщането обратно до някаква форма на VHDL технически не е невъзможно. Също както не е невъзможно компютъра да извежда съобщения на чист български, само че при компилация "смисъла" на изреченията се превежда до конкретна схема, а после от тая схема много трудно компютъра ще ти възстанови на чист български какъв й е бил смисъла...
А да гледаш една схема с няколко стотина хиляди елемента... си е живо безумие - може да се наслаждаваш, но не и да откриеш някакъв смисъл.

Благодаря за коментарите и просветлението и конкретните отговори. Вече знам малко повече и в този смисъл благодаря на форума и целите на раздела. Мъглата беше разсеяна и съм наясно, че при около 290 хиляди бита едва ли ще разбера нещо ако се преведе във вид на логически елементи. Разбрах и че макар компилиран код на С да може да се дизасемблира до разбираемо ниво, не е същото за програмируемите логики.

Благодаря!

Ами не е същото не е съвсем точно казано, отново може а го имаш на разбираемо ниво, но за да го разбереш е нужно малко повече разбиране, в ркайан сметка от файал с връзките може да си извадиш схемата и по нея да разбереш какво става.
Миро добре го е обеснил, само да отбележа че пишещия има представа какво ще се получи, дори много често знае какво ще се получи, не като изходен файл, а като схемно решение, и е много препоръчително след всяка компилация да с епроверява какво е сътворено на схемно ниво, и ако има нужда да се внасят корекции.

п.с. VHDL не е много нов език, като такъв е нов наистина в смисъл като VHDL, но HDL си има от доста време, ISP се води първия такъв език, не помня коя година беше 70-те май някъде, от там нататък идеите са същите.

Да VHDL като език е стар наистина, поначало той е създаден от американските военни мисля беше за описване на симулации, а не точно за конструиране. Става въпрос че за нас простосмъртните VHDL реално стана достъпен преди около 5 години. Въпреки че и преди това имаше компилатори, но бяха толкова бъгливи че нямаше смисъл да се мъчи човек... Или пък тези които работеха не компилираха за прости CPLD-та и пак бяха неизползваеми за мен, щото аз не правя ASIC-ци

За проверка на компилацията - да, проверяват се простите HDL-и от сорта на ABEL. Особено при CPLD-та където ако имаш критичен сигнал може да провериш дали го смятана в една клетка, т.е. на едно ниво или го разхвърля в няколко клетки и вдига нивата, т.е. забавя сигнала. Или пък да видиш разпределението, защото в някои CPLD-та макроклетките са групирани на групи и ако трябва сигнал да се прехвърли от една клетка в друга клетка от различна група се налага да се използва допълнителна междинна клетка.
И като ресурсите почнат да се изчерпват почва да прави простотии - сигнали ги прехвърля от една група в друга, после ги връща обратно и така изяжда още повече ресурси. Тъпото е че нямаш никакъв контрол и като пипнеш на едно място, то разбутва всичко и така се почва една игра на котка и мишка...
Да проверявам VHDL компилатор досега просто не ми се е налагало. Ако имам някакви изисквания за времена и т.н. мога да си ги заложа в сорса - от там нататък компилатора знае кои са му критичните сигнали и си ги рутва с приоритет и обикновено се справя много добре. Ако не успее да спази изискванията които са му наложени - той сам си казва, няма нужда да го проверявам
Освен това обикновено всеки компилатор прави множество анализи и статистистика. Разпознава колко клока има в дизайна, след компилация ти дава каква може да е реалната максимална честота на всеки клок. Ако искаш гледаш времена и закъснения на всеки сигнал и всичко каквото те интересува...
Просто няма никакъв смисъл да му се ровиш из изходните файлове, първо че те доста се различават от оригиналните сорсове и второ всяка информация която те интересува може да си я получиш в доста по-човешки вид

@miro_atc
Можеш ли да препоръчаш някоя книга за VHDL, а още по добре ако е
достъпна и в електронен вид?