Show your FPGA of CPLD projects.

Ik wilde net in het FPGA topic een simpel voorbeeldje geven om mensen een idee te geven hoe zoiets in z'n werk gaat. Maar het past ook wel goed in dit topic dus bij deze een eenvoudig voorbeeld:

Stel je wilt een PWM controller maken die aangestuurd wordt door iets (mogelijk een ander stuk logica, of een microcontroller zo je wilt). Om het eenvoudig te houden wordt het 2 kanalen, met 4 bits resolutie per kanaal. De kanalen kun je programmeren door op de juiste inputs het kanaal te kiezen en de gewenste PWM waarde (duty cycle), en dan de data clock even een positief pulsje te geven. De controller onthoudt dit dan als nieuwe waarde.

Hoe begin je hier aan? Het makkelijkst is in Quartus er een 'block' voor te maken, een soort submodule. Deze kun je later dan aan andere blokken of inputs/outputs verbinden, en hergebruiken in andere projecten.

Dit ziet er zo uit:

het middelste is het block, deze kan inputs en outputs hebben zoals je ziet. Zo'n block is gekoppeld aan code, bijvoorbeeld verilog. De [3..0] suffix geeft aan dat het om een bus gaat van 4 bits breed.

Om het blok heen zie je ook nog inputs en outputs, met daartussen verbindingen naar het block. Dit zijn losse input en outputs die je later kunt koppelen aan een pin. Je kunt dus zelf bij de CPLD en FPGA kiezen op welke pinnen je deze inputs en outputs gaat zetten, net waar je het handig lijkt.

Je ziet dat er 4 inputs zijn: clk, channel, data_clk en duty (4 bits). clk is een algemeen kloksignaal dat dient op de PWM uit te kunnen voeren (zonder klok geen PWM natuurlijk). Deze staat verder los van de andere signalen. Via de andere inputs kun je de 2 PWM kanalen instellen. Met channel kies je welk kanaal je wilt (0 of 1), duty geef je de duty cycle op (0 tot 15, het is 4-bits). Zodra je data_clk hoog maakt zal de controller de waarde van duty lezen en onthouden voor het opgegeven kanaal.

Er is 1 output, of eigenlijk een bus van 2 outputs. pwm[0] en pwm[1] zijn de gegenereerde PWM signalen. Volgende stap is dat het pwm_controller block te implementeren. Mijn favoriete taal daarvoor is Verilog.

De volledige module ziet er zo uit:

module pwm_controller (clk, channel, data_clk, duty, pwm);
    input   clk;
    input   channel;
    input   data_clk;
    input   [3:0] duty;
    output  [1:0] pwm;

    reg [3:0] counter;
    reg [3:0] pwm_duty [0:0];
    reg [1:0] pwm;

    always @(posedge data_clk) begin
        case(channel)
            0: pwm_duty[0] <= duty;
            1: pwm_duty[1] <= duty;
        endcase
    end

    always @(posedge clk) begin
        counter <= counter + 1'b1;
        pwm[0] <= pwm_duty[0] > counter;
        pwm[1] <= pwm_duty[1] > counter;
    end
endmodule

Ik zal het stap voor stap doorlopen:

module pwm_controller (clk, channel, data_clk, duty, pwm);
    input   clk;
    input   channel;
    input   data_clk;
    input   [3:0] duty;
    output  [1:0] pwm;

Dit definieert de module pwm_controller. Alles in verilog moet binnen een module vallen. De signalen tussen (haakjes) zijn de signalen die naar binnen of buiten moeten (inputs en outputs). Daaronder worden ze met input en output statements nog eens verder gedefinieerd. "input clk" betekent simpelweg dat clk een input is voor de module. De [3:0] en [1:0] delen zijn weer bussen. "output [1:0] pwm" is dus een bus van 2 outputs. In verilog staat de range voor de naam in plaats van erachter. Erachter kan ook maar dit heeft een hele andere betekenis.

De inputs en outputs bestaan nu wel maar zijn nog nergens aan verbonden. Zie het maar als loshangende draden met een naam.

    reg [3:0] counter;
    reg [3:0] pwm_duty [0:0];
    reg [1:0] pwm;

Hier worden registers gedefinieerd. Een register is een klein geheugen, je kunt er wat in stoppen en dat wordt onthouden totdat je het veranderd. In programmeertalen zouden dit variabelen zijn, maar hier moet je het echt zien als hardware geheugens. Counter is een simpel geheugen van 4 bits breed, pwm eentje van 2 bits. pwm_duty is wat ingewikkelder, hier staat zowel voor als achter de naam een range. De [3:0] ervoor geeft weer aan dat het 4 bits breed is. De [0:0] erachter echter geeft een array aan, vergelijkbaar met programmeertalen. Je krijgt dus meerder pwm_duty's die indexeerbaar zijn. In hardware betekent dit dat je een geheugen aan het maken bent. [3:0] is de breedte van het geheugen (4 bits), [0:0] is de adres-bus van het geheugen (1-bit). 0:0 ziet er wat vaag uit maar dat komt omdat verilog altijd [begin:eind] ranges heeft. 0:0 is 1 bit dus, en omdat die twee waarden kan hebben (0 en 1) betekent dit dat het een geheugen is met 2 adressen. Samengevat: pwm_duty is een geheugen voor 2 waardes van 4-bits.

Het pwm register heeft overigens dezelfde naam als een output. In dat geval worden ze ook direct aan elkaar gekoppeld. Wat je in het geheugen pwm zet wordt dus ook direct aan de output zichtbaar.

    always @(posedge data_clk) begin
        case(channel)
            0: pwm_duty[0] <= duty;
            1: pwm_duty[1] <= duty;
        endcase
    end

Dit is de code om de kanalen in te stellen. De always constructie definieert hardware die uitgevoerd wordt onder een bepaalde conditie. De conditie is hier 'posedge data_clk', wat betekent dat het stuk ertussen uitgevoerd gaat worden bij een positieve flank (positive edge = posedge) op data_clk.
Daartussen heb je een case statement op channel. In een programmeertaal zou zo'n case statement kijken wat de waarde is van channel en afhankelijk daarvan 1 stukje code uitvoeren. In hardware betekent een case iets soortgelijks maar dan in hardware. Afhankelijk van de waarde van channel wordt een van de stukjes hardware aangestuurd. In dit gevla zijn er twee mogelijkheden voor channel: 0 of 1. Afhankelijk van channel wordt 1 van de twee waarden in het pwm_duty geheugen veranderd naar de waarde van duty.

"pwm_duty[0] <= duty". Dit betekent: kopieer de waarde van duty naar pwm_duty[0]. pwm_duty[0] is de eerste 4-bits waarde in het geheugen, pwm_duty[1] is de tweede. Channel kiest er een van de twee uit, en naar die wordt een nieuwe waarde gekopieerd. Omdat het geheugen is zal deze waarde vanaf dat moment onthouden worden.

    always @(posedge clk) begin
        counter <= counter + 1'b1;
        pwm[0] <= pwm_duty[0] > counter;
        pwm[1] <= pwm_duty[1] > counter;
    end
endmodule

Dit is het stuk dat de PWM signalen genereert. Weer een always constructie, maar dit keer op de positieve flank van clk. Dit is een van de meest voorkomende constructies. Elke keer dat het clk signaal tikt worden er drie dingen gedaan:
De counter wordt opgehoogd met 1, en de twee PWM outputs worden veranderd. pwm[0] is de eerste lijn van de 2 bits bus. pmw[1] is de tweede. "pwm[0] <= pwm_duty[0] > counter" valt in twee delen. De eerste is "pwm_duty[0] > counter". Dit vergelijkt of pwm_duty[0] (de eerste geheugenwaarde) groter is dan de huidige counter. Als dat zo is geeft dit 1, anders 0. Het tweede deel is "pwm[0] <= {resultaat van eerste deel}". Dit stopt dus 1 of 0 in pwm[0] afhankelijk van of pwm_duty[0] groter of kleiner was dan counter. Dit is een makkelijke manier om PWM signalen te genereren.

Bedenk goed dat deze 3 regels parallel gebeuren! Het is niet zo dat eerst de counter wordt opgehoogd, dan het ene PWM kanaal ingesteld wordt en dan de tweede. Alle 3 gebeuren tegelijketijd. Sterker nog de counter waarde die in de vegelijking gebruikt wordt is de *vorige* waarde, niet de opgehoogde waarde. Dat kan ook niet omdat de ophoging tegelijkertijd gebeurt met de vergelijking. Je zou verwachten dat dit problemen geeft als je counter gaat veranderen terwijl je deze tegelijkertijd gebruikt
in een vergelijking. Dat zou ook problemen geven, vandaar dat de nieuwe waarde van counter (en ook van pwm[0] en pwm[1]) pas bij het volgende kloksignaal echt opgeslagen wordt. Een ophoging van de counter merk je dus pas bij de volgende positieve clk flank, tijdens 1 flank blijven alle waarden hetzelfde.

Als je dit nu in Quartus synthetiseert kun je in de RTL viewer zien hoe het er aan hardware uit gaat zien. Dit is nog een hoger niveau dan hoe het echt in een CPLD/FPGA zit, maar wel bruikbaar en leesbaarder:

Als je hier links begint zie je de inputs. Channel gaat door een decoder. Deze geeft aan 1 van de 2 outputs een 1, afhankelijk van of de input 0 of 1 is. In het midden zie je twee geheugens van 4-bits. Via de output van de decoder wordt 1 van de twee geheugens geprogrammeerd, afhankelijk van channel. Dit zijn dus pwm_duty[0] en pwm_duty[1]. Dit gebeurt door het write address te kiezen (0 of 1), elk geheugen gebruikt maar een van de twee adressen (waarschijnlijk wordt dit later allemaal in 1 geheugen gestopt). duty[3..0] zit aan de data-in inputs van de geheugens, zodat deze waarde geprogrammeerd wordt. data_clk is de clock voor de geheugens wat logisch is omdat we de data willen instellen wanneer data_clk hoog wordt. Beide geheugens hebben een output van 4-bits, elk stelt een PWM waarde voor.

Links bovenin zie je een adder (opteller) en counter. Counter is een 4-bits register. De adder heeft bij z'n A input de output van counter zelf (de vorige waarde dus), en aan z'n B input de vaste waarde '1' (het valt niet te lezen maar er staat 4'h1 wat 0001 betekent). De adder voegt dus counter en 1 samen, oftewel counter + 1. De output daarvan gaat weer naar counter. Deze slaat echter alleen de waarde op als de clock hoog is (het driehoekje), en die zit weer aan clk vast. Dus elke keer dat clk hoog wordt zal de counter de output van de addder (= counter + 1) opslaan, dus zichzelf met 1 ophogen.

Het genereren van PWM zit tenslotte helemaal rechts. Je ziet daar twee comparators. De A inputs zitten vast aan counter, wat logisch is gezien we in de code ook met counter vergeleken. De andere input (B) zit aan de geheugencellen die de PWM waardes onthouden. Elke comparator vergelijkt dus een van de PWM waardes met counter. Het resultaat komt op out. Je ziet hier ook gode dat beide vergelijkingen tegelijk gebeuren, evenals het ophogen van de klok.

Helemaal rechtsboven heb je dan een 2-bits register die de PWM outputs vasthoudt. Aan z'n 2-bit input (D) zitten de outputs van de comparators, die er vlak voor samengevoegd (twee dunne lijntjes worden 1 dikke). Tenslotte komt de output (Q) er als 2-bits bus weer uit.

Laatste stap in dit geheel is de simulatie. Je kunt in Quartus een aantal inputs opgeven en daar signalen voor 'tekenen'. Quartus simuleert het dan en geeft je de bijbehorende output. Dit wordt als volgt:

Alleen de laatste twee PWM signalen zijn outputs, de rest zijn inputs die zelf opgegeven zijn.

clk is gewoon een willekeurig kloksignaal. In het begin zie je dat beide pwm outputs laag blijven. Standaard staan de geheugens op 0 (eigenlijk zou je hier nog een reset lijn voor moeten maken maar goed). Op een gegeven moment zetten we duty op de waarde 8 (4-bits), channel laten we laag (dus kanaal 0). Zodra data_clk een positieve puls krijgt zie je dat pwm[0] gaat veranderen. Eerst nog een kort signaal dat niet klopt met de duty cycle (8 is 50%) maar dat komt omdat we halverwege de PWM cyclus zaten. Daarna zie je dat pwm[0] een mooi 50% PWM signaal wordt.

Even verderop stellen we ook het tweede kanaal (1) in. Channel gaat nu op 1, de waarde wordt 0xC (12, 75%) en weer geven we data_clk een puls. pwm[0] blijft onveranderd zoals het hoort. pwm[1] wordt echter (na weer een keer een klein pulsje vanwege dezelfde reden) een 75% PWM signaal. Het werkt!

Dit was een flink verhaal maar ik hoop dat het nu een beetje duidelijk is wat de manier van programmeren en denken is. Mocht je nog vragen hebben stel ze gerust.

Misschien nog handig om te weten: dit bij elkaar neemt 14 LE's in beslag.

Perfecte topic om mijn projectje te laten zien Ik heb een soort van development platform gemaakt gebasseerd op de MAX7128. Het bestaat natuurlijk uit een hoofdmodule, met de CPLD. Een DEBUG bordje om dingen er mee te testen, op dit bordje zijn er wat knopjes, ledjes, segmentdisplays en schakelaars. Byteblaster zit er ook nog bij. En nog een voedings printje, die 5volt voor de core leverd en 3v3/5v voor de IO pinnen.

Ik had hier mee een Pong spel gemaakt op een 10x10 led matrix. Ik moet het nog verbeteren, de bal verdwijnt soms van het speelveld . Hier is de opstelling ervan:

ziet er leuk uit!

Ik heb een paar weken terug weer enkele studiepunten verdiend met een fpga project
We moest mbv 2 ispgal's een ad/da print aansturen, en de daarop gecreëerde digitale signalen analyseren voor een topdetector. Hiervoor heb ik de topdetector in abel geschreven, en het verhaal voor de controller heb ik in statecad gemaakt. Zal eens zoeken voor foto's

Wow! dat MAX printje is de goede oplossing om te starten met CPLD's. Kijk dit is ongeveer zoiets dat heel lowcost zou moeten kunnen voorbestukt gemaakt worden zodat je enkel de applicatie er rond verder moet uitbouwen. Nu zoals je hier gedaan hebt met al die kleine modules.

De PWM van madwizard hierboven beschreven zou je er direct kunnen inblazen. Buiten het soldeer probleem eigen aan die heel fijne pitch van de MAX is er geen enkel probleem om zoiets te maken. En duur zal het zeker niet zijn. De modulaire opbouw laat toe heel veel te experimenteren zonder telkens een nieuwe MAX device te moeten kopen.

Mooie realisatie!

Update:
Oja, met dezelfde layout zou je ook de grotere versie tot 1270 LE's kunnen bestukken wat je mogelijkheden nog verder uitbereid!

[Leekmodus]
OK... Nu zie ik de term FPGA een paar keer voorbij komen in dit forum, maar wat is het dan?
Ik werk met PIC. Is dat vergelijkbaar?
Of is dit heel wat anders.
Vooropgesteld dat de foto's me wel intrigeren.

Hetzelfde geldt overigens ook voor de CPLD, waarvan ik ook niet weet wat het is...
[/leekmodus] _{iets zegt mij dat mijn leekmodus voorlopig nog niet voorbij is}

Die "kleine" CPLD (= MAXII centraal IC) die MiniKObo hier toont kun je vergelijken met een doos gewone IC's van 64 stuks 74ls74 van vroeger, ongeveer 128 IC's 74LS00 samengebracht in die behuizing. Via de Quartus tool ga je die IC's aan elkaar verbinden tot een schakeling met als resultaat dat je functie aan de I/O pinnen eruitkomt, net zoals anders je software functie uit je PIC komt!

Maar de werkbare snelheid kan tot 100 maal of meer sneller met die CPLD!

zie hier de expirimenteerbordjes door school geleverd. links de ad/da omzetter, rechts de 2 ispgal's

[Bericht gewijzigd door vince_zld op zaterdag 3 februari 2007 16:05:33 ]

Show your FPGA of CPLD projects. -> Show your FPGA OR CPLD projects. (?)
Wel leuk spul allemaal.

[Bericht gewijzigd door shortcircuit op zaterdag 3 februari 2007 16:14:55 ]

Op 3 februari 2007 15:38:03 schreef fotoopa:
Wow! dat MAX printje is de goede oplossing om te starten met CPLD's. Kijk dit is ongeveer zoiets dat heel lowcost zou moeten kunnen voorbestukt gemaakt worden zodat je enkel de applicatie er rond verder moet uitbouwen. Nu zoals je hier gedaan hebt met al die kleine modules.

*/knip/*

Het printje is zo ontworpen dat de pinheaders door een gaatjesbord past, geen halve afstanden waar je tussen gaatjes moet boren. Op de hoofdprint zitten zowel aan de boven- als onderkant 2 IO headers, en dit op een enkellaags printje. Het solderen van de headers is niet echt user-friendly.

Update:
Oja, met dezelfde layout zou je ook de grotere versie tot 1270 LE's kunnen bestukken wat je mogelijkheden nog verder uitbereid!

Over welke chip heb je het nu? Ik gebruik een MAX7128, geen MAXII serie. Volgens mij haal je die twee even door elkaar . Het is een 100pins chip en met maximaal 80 io-pinnen (4x20pins headers ).

Op 3 februari 2007 16:29:17 schreef miniK0bo:
[...]
Over welke chip heb je het nu? Ik gebruik een MAX7128, geen MAXII serie. Volgens mij haal je die twee even door elkaar . Het is een 100pins chip en met maximaal 80 io-pinnen (4x20pins headers ).

Ja idd, Voor nieuwe designs zou je nog beter de MAXII serie kunnen gebruiken, het solderen is ongeveer (100 of 144 pins) hetzelfde, ook het princiep van plugup! Maar uiteindelijk maak je met beide versie's mooie projectjes. Die MAX7128 is wel 5V, de MAXII moet je rekening houden met 3V3.

Nog een van mijn eerste projectjes, nog met een EPM7032LCC44. Die kon je toen nog niet incircuit programmeren. Het was de kleinste device van Altera. Het ontwerpje was bedoeld om mijn gasten te leren werken met de logische functie's, ze konden via een drukknopje een functie kiezen die werd aangeduid met een led terwijl ze dan de 2 ingangen konden bedienen waarbij ze het resultaat op de uitgangs led zagen. Er was ook een up/down teller en die kon je bcd, octal of hex laten tellen. Hierbij een paar foto's van de samenbouw en het interne:

Op 3 februari 2007 13:16:54 schreef madwizard:
een fantastisch goede uitleg !

en ook dit :

De volledige module ziet er zo uit:

module pwm_controller (clk, channel, data_clk, duty, pwm);
    input   clk;
    input   channel;
    input   data_clk;
    input   [3:0] duty;
    output  [1:0] pwm;

misschien weet je dit niet maar : Quartus is verilog2000 compliant ... al dat gedefinieer hoeft dus niet meer

module pwm_controller (
    input   wire clk,
    input   wire channel,
    input   wire data_clk,
    input   wire [3:0] duty,
    output  reg [1:0] pwm );

en je kan gelijk meegeven of het een register of een draad is ...

tis duidelijker om te lezen omdat je niet op 3 plaatsen moet gaan zoeken wat voor signaal het nu juist is ...

en tis weer een hoop tikwerk en ene hoop mogelijke punten van frustratie ( eh , godver... waarom compileert da nu niet ,... ah ene tikfaut ... ) weg ....

je kan nu ook blokken verilog code in ene for next zetten.
en je kan ook arrays laten genereren vanuit formules nu.

stel je maaktdie pwm generator cel.
je definieert bovenaan een constantie die aangeeft hoeveel pwm's je nodig hebt ....

je zet al je pwm code in ene 'generate' blok.
daarbuit zet je een for loop gebaseerd op die constante.

als je nu 3 pwm generators nodig hebt zet je die constante op 3 en de synthesizer genereert je 3 pwm blokken ( en door middle van de formules die je gezet hebt scalen de register cellen mee .

als je morgen in een design 256 pwms nodig hebt : 1 constante aanpassen en klaar.
addressbus en alles scaled automatisch mee.

das wat er gebeurt in die acrowizards: die code daar is in verilog2000 gemaakt. al wat ze doen is een paar constanten aan passen en huppekee : nieuw blok.

http://www.lcdm-eng.com/verilog2000.pdf

[Bericht gewijzigd door free_electron op zaterdag 3 februari 2007 17:18:48 ]

Op 3 februari 2007 17:03:07 schreef free_electron:
misschien weet je dit niet maar : Quartus is verilog2000 compliant ... al dat gedefinieer hoeft dus niet meer
[...]
en je kan gelijk meegeven of het een register of een draad is ...

Ik wist wel ergens nog dat het niet meer dubbel op hoefde alleen hoe het precies zat wist ik niet meer. Ook is de hele module header eigenlijk gegenereerd door Quartus zelf en ik wist niet of die het nog zou kunnen syncen met het blokkenschema als ik het anders zou doen.

tis duidelijker om te lezen omdat je niet op 3 plaatsen moet gaan zoeken wat voor signaal het nu juist is

Zeker, scheelt een hoop verwarring.

je kan nu ook blokken verilog code in ene for next zetten.
en je kan ook arrays laten genereren vanuit formules nu.

Ja dat had ik gezien, kan je for loops trouwens ook buiten always blocks zetten? Dus een for loop van assignments? Zoiets?

for (i=0;i<4;i++)
  assign iets[i] = iets_anders[i] + nog_iets[i];

Je kan er wel een always block voor bedenken maar technisch gezien zou dit toch ook geen probleem moeten zijn zolang i eenvoudig te bepalen is?
edit: Ah ik zie in het pdfje al iets over generate loops staan, ziet er handig uit. Leuke PDF!

stel je maaktdie pwm generator cel.
je definieert bovenaan een constantie die aangeeft hoeveel pwm's je nodig hebt ....

Heb ik ook aan gedacht, alleen zelfde met het blokkenschema, werkt de synchronisatie nog als je parameters gaat gebruiken?

Allemaal goede tips verder, ik heb het voor de duidelijkheid allemaal een beetje beperkt. Het case statement had ook makkelijk een array toewijzing kunnen zijn met channel als index. Ook beter uitbreidbaar.

Een project waar ik meer werk mee had was een video project. Zoals reeds vermeld in de andere topics schakelde ik een videosignaal tussen 9 TV's. Ik kon iedere kombinatie sturen. De niet gestuurde TV('s) waren geblankt op het zwart niveau. Er was slechts 1 video bron wat wilde zeggen als je meer dan 1 TV inschakelde het dezelfde beelden waren. Maar door goede combinatie's kon je heel mooie effecten bekomen. De meest spectaculaire waren iets van de ene naar de andere zijde laten lopen. De beelden stapten als het ware aan de ene zijde in de TV en gingen door de een na de andere TV om na de laatste eruit te stappen. Je moest natuurlijk specifieke opnames maken. Maar met het gebruik van 3D computer animatie's kon je enorme mooie effecten bekomen. Ook de klank was meegeschakeld en als je eens op alle TV's de klank inschakelde kon dit nogal een lawaaierig effect hebben.

Deze videotape heb ik nog steeds bewaart waardoor ik het systeem nog kan laten werken. De totale demo duurt ongeveer 15 minuten.

De video die deze beelden moest sturen was een digitale tape. Op het stereo klankspoor was 1 spoor voorbehouden voor de audio gestuurde commando's. Een biphaze toon stuurde dit. deze audio signalen werden aangemaakt via een audio editor en later in de video frame ingebracht. multiple blokken audio pasten exact in een videoframe. Hierdoor konden de klank en de beelden zelfs per frame geschakeld worden op eenderwelke combinatie van de 9 TV's.
hierbij 2 foto's, de eerste toont de 9 video channel module terwijl de 2de board de CPLD's bevatte. Op die kaart stonden een 10KE50 en een EMP7192 maar enkel de EPM werd gebruikt. Deze test kaart had zowel een VME bus als een ISA bus en was bedoeld om nieuwe CPLD toepassingen te leren gebruiken.

een paar fotokes van wat ik thuis liggen heb ( de echte 'spielery' bordjes liggen opt werk en die kan ik om confidentiality redenen niet posten )

een beetje van mijn altera collectie. epm7064,7128,7160,7256 en7512s alsook ep1c3 cyclones

origneel MAXII experimenteerboard van altera. deze heeft een PCI en USB interface. inpluggen in de computer en je hetb een PCI kaart. voor usb gebruiken ze een ftdi245

das het elektuur bord. kan natuurlijk niet ontbreken.

Altium Livedesign board met altera erop. kostte 99 dollar.. in clusief 30 dagen licence van altium deigner.
heel leuk omdat je allerhande ip cores cadeau krijgt bij altium ( waaronder 8051 core ... )

nog een altium livedesign maar nu met Zie-links erop ( xilinx ) ook 99 $

de reden van die 2 borden is dat je in altium designereen project kan maken wat fabrikantloos is. pas op het laatste geef je op dat het voor altera,lattice,cypress,quicklogic of altera is , en altium designer doet de rest.

@ Free_electron

Kwijl kwijl, ge kunt er zo zeker geen opsturen. Ge hebt er toch genoeg liggen

En natuurlijk mijn complete uitrusting voor vliegende beestjes te fotograferen. Ik heb daarvan 2 complete versie's gemaakt, eentje met de cyclone EP1C3 en eentje met de EP1C6. Hierbij enkele foto's van de eerste versie ( jan 2005)

De laatste versie van feb 2006 is hier te zien in opbouw met de EP1C6 cyclone chip. De meeste functie's zijn gelijkaardig aan de voorgaande versie. Enkel de shutter wordt nu aangestuurt met 150V ipv 50V voor dezelfde magneet wat een enorme verbetering geeft in accesstijd van de magneet. Natuurlijk is de controle van de zelfde magneet nu gebonden aan een heel juiste timing want 150V op een 6V magneet plaatsen moet binnen nauwe grenzen gebeuren. Daarom heb ik 2 FETs van 400V 12A samenverbonden om deze magneet te sturen en zit nog een 0.47 ohm weerstand in serie om de stroom binnen de veilige grenzen te houden.

Merk ook die 1.100U uF/330V elco op. Dit is een special flash type condensator die bijna geen spanningsverlies heeft. Eens deze condensator is opgeladen blijft hij dagen lang zijn spanning behouden. Ik heb een dc/ac convertor van 150V die dan via een fast recovery diode een gelijkspanning afgeeft gebruikt om via een PWM schakeling en een comparator de nodige spanning voor de magneet instelbaar te maken.

De PWM bevat een hysteresis zodat hij afvalt op 150.5V en weer aangaat op 149.5V. Ik ga dus via de FPGA de PWM waarde gaan wijzigen eens hij zijn spanning heeft bereikt!

Ik kan bijgevolg die 150V instellen via mijn controlbox tussen 0V en 250V. Hoewel deze schakeling bijna geen stroom kan leveren laad ze de eleco op in 2 min. Maar daarna hoef hij maar om de 5 min gedurende 2 sec even bij te pompen. Na een shutter bevel is de elco ietjes ontladen en wordt weer gedurende een 5 tal seconden bijgepompt. Voordeel hiervan is dat die dc/ac convertor slechts enkele mA verbruikt enkel als hij moet werken. Hierdoor wordt bijna geen verbruik van mijn batterijen genomen wat de werkduur hiervan tot 10 uur toelaat. Dit ganse systeem is draagbaar en wordt vooral in de field gebruikt.

Op 3 februari 2007 20:24:51 schreef fotoopa:
En natuurlijk mijn complete uitrusting voor vliegende beestjes te fotograferen.

opa, ik wordt toch wel steeds nieuwsgieriger naar wat je nou eigenlijk doet met die ernorme berg hardware. Fotograferen? Dat doe ik gewoon met een fotocamera. Maar misschien is dat te makkelijk Kun je het in het kort uitleggen?

Op 3 februari 2007 22:53:33 schreef flipflop:
[...]
opa, ik wordt toch wel steeds nieuwsgieriger naar wat je nou eigenlijk doet met die ernorme berg hardware. Fotograferen? Dat doe ik gewoon met een fotocamera. Maar misschien is dat te makkelijk Kun je het in het kort uitleggen?

zie zijn profiel en kijk dan eens op zijn homepage ? http://www.pbase.com/fotoopa

verderstaat er in de andere FGPA topics al een hele hoop uitleg over deze box met hardware

Op 3 februari 2007 22:53:33 schreef flipflop:
[...]
opa, ik wordt toch wel steeds nieuwsgieriger naar wat je nou eigenlijk doet met die ernorme berg hardware. Fotograferen? Dat doe ik gewoon met een fotocamera. Maar misschien is dat te makkelijk Kun je het in het kort uitleggen?

Idd, ik doet heel weinig "gewoon" fotografie!

Maar meer algemeen kun je stellen dat ik mijn hobby's maximaal tracht te ondersteunen met een flinke dossis toegepaste electronica zoals CPLD's en FPGA's. Al heel mijn leven had ik een sterke voorkeur voor alles wat electronica is en ben dan ook begonnen als een verwente radioamateur rond de jaren 1960 ( ex ON5DK). Maar toen was er geen de minste sprake van kopen van een transceiver maar alles zelf te bouwen. Ik heb al deze ervaringen opgedaan, complete zenders eerst enkel CW, daarna AM, maar vooral een 6 bands SSB zender 150W ( 80 40 20 15 en 10 m band) nog later overgegaan ook zelfbouw naar 2m en 70 cm band, ook TTY, slowscan en TV gedaan om in de jaren 1978 te starten met de eerste op de markt gekomen µcomputerkit de "KIM" met een 6502, keypad klaviertje, 7 segment display's voor adres en data lijnen en 1K ram onboard.

Gestart als mechnieker voelde ik dat mijn jonge keuze totaal verkeerd was en na 15 jaar te hebben gewerkt als technisch tekenaar ben ik van de ene dag op de andere overgeschakeld naar de electronica en daar 26 jaar blijven werken als hardware systeem ontwerper.

Heel mijn leven heb ik moeten ( en mogen) bijscholen maar als tegenprestatie had ik een uiterst boeiende job en kon ik gebruik maken van de allerlaatste technologie. Spijtig nu ik op pensioen ben verlies je een beetje de heel snelle evolutie maar gelukkig kan ik mij verder vasthouden aan de mooie FPGA bouwstenen zoals de cyclone II devices die ik nu praktisch integreer om verfijnde resultaten te bekomen bij al mijn experimenten.

@fotoopa: Ongelooflijk wat je daar allemaal in elkaar zet als 'hobby projectjes'! Ik had al eens eerder wat voorbij zien komen in andere topics, maar het is echt verbazingwekkend.

Ik hoop dat ik na mijn pensioen (==tijd genoeg) ook nog zo met alle technische ontwikkelingen kan meekomen!

...

OK, die link had ik nog niet eerder gezien. Ik snap nu ook waarom je de externe shutter nodig hebt. Die van de camera is niet snel genoeg blijkbaar? En de lasers voor detectie, ok. Mooie fotos overigens. Vooral die insecten.
Goed, back to the topic maar weer. Dank.

Op 4 februari 2007 13:43:52 schreef flipflop:... Ik snap nu ook waarom je de externe shutter nodig hebt. Die van de camera is niet snel genoeg blijkbaar? En de lasers voor detectie, ok.

Ja idd. Ik gebruik nu de D200 nikon camera hiervoor en dit is reeds een vrij snelle camera maar toch heeft hij minimaal 55 msec nodig tussen commando en foto nemen. Deze tijd is veel te lang. Die externe shutter met de extreeme hoge magneetspanning van 150V op een 6V magneet samen met de mechanische externe shutter doet dit in 4.5 msec. De lasers doen de detectie in 32 usec.

De flitsen moet ik ook zelf sturen, juist in de heel korte window dat de externe shutter openstaat, nl juist na die 4.5 msec. flitstijden liggen rond de 200 usec duur. Een FPGA is voor al deze functie's ideaal omdat je alle timingen heel precies en konstant kunt aanhouden.

De lasers zijn trouwens gepulst en gemultiplexed. De on-tijd van de laser is 1/4 van een laser cyclus of 8 usec. Het window van de photodiode die de laser puls ontvangt ligt ietjes verschoven waardoor de timing ook moet aangepast worden. Maar er zjn natuurlijk veel gelijktijdige zaken die nog moeten beheerd worden want de lasers mogen ook niet aanblijven op het moment dat de foto zelf gemaakt wordt anders staat daar een rood puntje op....

Zal ook even mijn FPGA project tonen. Het bestaat uit een Xilinx Spartan 3 en een Cypress EZ-USB uC (8052 met USB).

Het geheel is opgezet om als universeel experimenteer systeem te dienen. De EZ-USB is zo met de FPGA gekoppeld zodat deze de FPGA kan configureren en na de configuratie data van/naar de FPGA kan sturen (nog niet getest, prog nu via de JTAG).

Op de foto is te zien dat er een PSone LCD aan hangt. De FPGA genereerd hiervoor het RGB video signaal. Verder zit er in de FPGA een character generator en een PS2 mouse driver. Het kruisje kan je dus met de muis bedienen en de X en Y positie worden (in hex) op het scherm getoond.

Oja, het board wordt op dit moment volledig vanuit de USB gevoed. Een TPS75003 zorgt voor de benodigde spanningen (1.2V,2.5V en 3.3V)