Differenze CPLD/FPGA
Darius
Una CPLD è la sorella maggiore delle vecchie PLD (PAL, GAL) formata da
centinaia di queste che formano le celle, poi c'è una matrice che le
connette assieme secondo quanto stipato dentro una eprom che sta dentro la
CPLD.
Oggi si programmano con lo standard JTAG e io qualcosina con ISE Webpack
dellla Xlinxs l'ho fatta, con il disegnino dello schema non con quella
schifezza che non capisco che motivo c'era di inventarlo di VHDL ( o
Verilog).
Ora che differenze ci sono con una FPGA?
Sembra che le eprom che tiene conto delle connessioni non sia interna ma
deve essere messa esterna ed inoltre le FPGA sono molto più grandi e le
celle sono diverse dalle CPLD vero?
Allora perché ho visto che le FPGA si programmano sempre in JTAG come le
CPLD cosa si programma se non hanno una eprom dentro?
Non bisogna programmare la boot eprom e poi conetterla alla FPGA? Forse
l'interfaccia JTAG per le FPGA serve proprio per connetterle alla boot
eprom?
Fatemi un po di luce vi prego cosi inizio pure a divertirmi con le FPGA.
Ciao Dario
Rinux
> dellla Xlinxs l'ho fatta, con il disegnino dello schema non con quella
> schifezza che non capisco che motivo c'era di inventarlo di VHDL ( o
> Verilog).
Sei un ragazzino :)
Darius
"Rinux" <ri...@iternet.it> ha scritto nel messaggio
news:b9b8mg$hq3cs$1...@ID-185871.news.dfncis.de...
Ha parlato mio nonno torna coi piedi per terra lustrascarpe!!!
Valeria Dal Monte
"Rinux" <ri...@iternet.it> ha scritto nel messaggio
news:b9b8mg$hq3cs$1...@ID-185871.news.dfncis.de...
Magari.
Questo qui é un trollus vulgaris senza valore.
Powermos
chiedo scusa:
Sono dei dispositivi logici programmabili (Field Programmable Gate Array).
In parole povere hai ha disposizione dei blocchi logici in genere denominati
macrocelle che possono
realizzare funzioni combinatorie (tramite look-up table LUT) e funzioni
sequenziali mediante FF di tipo D.
Questa miriade di macrocelle è interconnessa alle altre macrocelle tramite
connessioni che possono essere di
varia natura. Esistono delle connessioni a basso skew (ritardo) utilizzate
essenzialmente per la propagazione di
segnali di clock e linee "standard" utilizzante nel routing per i segnali di
tipo non clo-clock.
In sostanza il software che usi per programmare l'FPGA (sia di una caso
oppure di un'altra) non fa altro che
mappare tramite le risorse di connessione del dispositivo utilizzato lo
schematico oppure la macro VHDL nella corrispondente funzione logica dentro
il dispositivo fisico.
A questo livello di esposizione il concetto è molto generale infatti molti
tendono a confondere il concetto di FPGA con
quello di CPLD. Le FPGA, tanto per fare nomi XILINX, consentono di
interconnettere le macrocelle passando attraverso dei PIP cioè delle matrici
di interconnessione che, molto semplicemente, possono essere viste come
degli interruttori che connettono le righe e le colonne che saranno
utilizzate per propagare il segnale attraverso il dispositivo, questa
operazione la fa un particolare modulo del software detto router che procede
con il place ed il map del dispositivo. Il secondo tipo di dispositivo
programmabile è la CPLD che in soldoni è una macroestensione delle
vecchie PAL o GAL. In questo caso i percorsi di interconnessione non possono
essere modificati in modo dinamico dal router interconnettendo attraverso le
matrici di contatto, ma i segnali escono e rientrano in una matrice di
interconnessione globale (Global Routing Pool dalle LATTICE), in sostanza
con le CPLD se non si progetta in modo oculato è possibile congestionare le
risorse di connessione molto facilmente anche utilizzando il dispositivo in
modo ridotto (basso coverage), il vantaggio è che i ritardi sono predicibili
a priori, quindi potresti calcolarli anche a mano!!!
Per l'FPGA in senso classico il calcolo del ritardo è molto più complicato
perchè dipende essenzialmente dalla strategia di routing utilizzata dal
software.
Io uso sia FPGA XILINX che PLD della LATTICE, come software uso Foundation
3.1i che va molto bene, costava poco ed aime' non è più supportato dalla
XILINX.
Per maggiori info sono a disposizione, però dai un 'occhiata al sito
www.xilinx.com e guarda il datasheet dei seguenti dispositivi XC5202 e
Spartan. Sono entrambe FPGA ma con features differenti, in particolare la
Spartan presenta una matrice di interconnessione a 360° quindi da una
macrocella riesco ad andare verso tutte le altre, per la XC5202 le risore di
interconnessione sono polarizzate nel senso che le uscite di trovano da un
lato della macrocella e gli ingressi dall'altro. Per le PLD/CPLD vai sul
sito della lattice www.lattice.com e guarda il data-sheet della famiglia
1000 che sono delle PLD di piccolo taglio in package PQFP44 (plastico
quadrato a 44 pin in SMD oppure in package PLCC quello con i pin ripiegati
che può essere alloggiato in un apposito zoccolo da cs).
Questa è solo una veloce introduzione se ti serve altro fischia ... ciao
Ciao
Pow
--
----------------------------------------------------
Ama il tuo mestiere con passione
E' il significato della tua vita
Auguste Rodin (1840-1917)
"Darius" <Darius...@libero.it> ha scritto nel messaggio
news:b9b8ae$66a$1...@lacerta.tiscalinet.it...
Alessio Morale
news:b9b8ae$66a$1...@lacerta.tiscalinet.it...
> Oggi si programmano con lo standard JTAG e io qualcosina con ISE Webpack
> dellla Xlinxs l'ho fatta, con il disegnino dello schema non con quella
> schifezza che non capisco che motivo c'era di inventarlo di VHDL ( o
> Verilog).
La sindrome Windows colpisce ancora!!! :-)
Ringraziamo Microsoft per fatto involvere gli esseri umani in creature
Click-dipendenti.
Powermos
news:b9b8ae$66a$1...@lacerta.tiscalinet.it...
> Oggi si programmano con lo standard JTAG e io qualcosina con ISE Webpack
> dellla Xlinxs l'ho fatta, con il disegnino dello schema non con quella
> schifezza che non capisco che motivo c'era di inventarlo di VHDL ( o
> Verilog).
mi dispiace ma in questo caso devo dissentire fortemente, capisco il tuo
punto di vista, lavorare con lo schematico, da un certo punto di vista, può
sembrare molto veloce ed intuitivo, io ho iniziato proprio con lo schematic
entry per la programmazione delle FPGA XILINX e devo dire che mi sono sempre
trovato bene ed il tempo di sviluppo è stato sempre molto basso.
Adesso immagina che per esigenze di mercato ti trovi a dover ridurre il
costo del dispositivo al fine di poter essere concorrenziale, cosa fai?
Inizi a guardare se puoi rosicchiare qcsa sui componenti, ed ecco li,
l'FPGA, il progetto ha qualche anno, nel frattempo la tecnologia è maturata
e sono disponibili soluzioni differenti. Trovi il costruttore Y che ti offre
una FPGA che costa meno di quella che hai usato fino ad oggi, la cosa è
allettante, la valuti ed a questo punto nascono i problemi, la portabilità
del progetto.
Hai tutto come schematico all'interno del sw proprietario relativo al
dispositivo che hai usato, cambi dispositivo, cambi software e quindi gli
schematici te li devi ridisegnare (raramente trovi un sistema che li importi
tutti, recentemente sto valutando ALDEC-HDL che importa schematici di tutte
le versioni Foundation e li trasforma in HDL anche per i più recenti ISE, ma
il tool costa 7000$, mica bazzecole). Inoltre il nuovo dispositivo magari
non implementa della features che utilizzavi nel vecchio FPGA quindi devoi
ritoccare gli schemi e cosi via.
Il succo del discorso è sempre lo stesso, la portabilità, proprio come nei
software ti occorre un sistema che consenta di descrivere la logica che devi
implementare ad alto livello cioè in modo indipendete dal sistema che userai
per realizzare fisicamente il progetto. Questo lo puoi certamente fare con
il VHDL oppure il Verilog, anche se personalmente io ho iniziato a studiare
il VHDL che considero il linguaggio descrittivo per eccellenza, il Verilog è
un dialetto, ma tanto per iniziare ....
All'inizio trovarai qualche difficoltà, ma in seguito ti assicuro che ci
metterai molto meno a scrivere direttamente in VHDL piuttosto che disegnare
lo schematico, inoltre con il VHDL non ti preoccupi della piattaforma
utilizzata XILINX, ALTERA, LATTICE ... perchè il linguaggio utilizzato è
descrittivo, risulta portabile e tutti i costruttori di loigica hanno il
loro modulo VHDL. Quindi una volta scritto il progetto testato dal punto di
vista del funzionamento non ti resta che importare il progetto VHDL
all'interno dell'ambiente di sviluppo e compili per l'FPGA desiderata.
ALDEC-HDL consente anche di invocare i motori di place and route di terze
parti, quindi lavori in un solo ambiente e implementi il progetto per tutti
i dispositivi possibili, ti serve solo il modulo di place and route e map
per FPGA desiderato, questo ad esempio lo fai tramite Symplicity (8000$
cacchio!) forse il miglior software di mapping presente oggi sul mercato
(bada bene non faccio pubblicità sono solo considerazioni personali).
Se quindi vuoi un consiglio, poi sei libero di fare come preferisci, inizia
a studiare il VHDL, io sono all'inizio, ma comincio ad apprezzarlo e
sicuramente convertirò tutti i progetti della ditta in cui lavoro in
progetti VHDL.
Ciao
Pow
Powermos
news:b9b8ae$66a$1...@lacerta.tiscalinet.it...
> Oggi si programmano con lo standard JTAG e io qualcosina con ISE Webpack
> dellla Xlinxs l'ho fatta, con il disegnino dello schema non con quella
> schifezza che non capisco che motivo c'era di inventarlo di VHDL ( o
> Verilog).
mi dispiace ma in questo caso devo dissentire fortemente, capisco il tuo
Zmaster
> progetti VHDL.
Sempre il doppio click ah? :)
--
...:::Zmaster:::...
DSL powered
zmast[ANTISPAMSYSTEM]@freemail.it
www.zmasterworld.8m.com
Collaboratore del Media Player Project
Powermos
"Zmaster" <zmast[ANTISPAMSYSTEM]@freemail.it> ha scritto nel messaggio
news:wwOva.155141$K35.3...@news2.tin.it...
> > mi dispiace ma in questo caso devo dissentire fortemente, capisco il tuo
> [bla bla bla]
> > progetti VHDL.
>
> Sempre il doppio click ah? :)
OPS!!!!!!!!!
Rinux
> > dellla Xlinxs l'ho fatta, con il disegnino dello schema non con quella
> > schifezza che non capisco che motivo c'era di inventarlo di VHDL ( o
> > Verilog).
>
> La sindrome Windows colpisce ancora!!! :-)
> Ringraziamo Microsoft per fatto involvere gli esseri umani in creature
> Click-dipendenti.
Per questo gli ho detto che è un ragazzino :)