Programmierung einer RGB-LED mit R2R Netzwerk in Quartus II

[Florian R. (florifantasy)]

Hallo!
Ich habe ein verzwicktes Problem, denn ich soll für ein Uni-Projekt LEDs 
ansteuern. Evtl. gibt es hier nette Menschen, die bereits Erfahrungen 
mit meinem konkreten Problem gemacht haben?!
Kurz zur Erläuterung:
Aufgabe: Eine RGB-LED dazu bringen, die Farben des RGB-Spektrums 
abzulaufen.
Vorgabe: Es soll ein Altera DE2 Board mit Cyclon II (EP2C35F672C6N) 
Prozessor und ein R2R Netzwerk benutzt werden. Die Software dafür soll 
über Quartus II umgesetzt werden.
Leider habe ich noch keine Erfahrungen mit dieser Software und bin etwas 
überfordert mit der Gesamtaufgabe. Da wir dies auch praktisch umsetzen 
sollen, dachte ich hier könne mir vielleicht geholfen werden!
Eine einfachere Methode über PWM ist leider nicht erlaubt.
Ich bräuchte eigentlich erstmal nur eine Einstiegshilfe in VHDL. Mir 
fehlt der Anfang - würde mich gerne reinknien ;)

(Ich weiß bis jetzt, dass ich 8bit, also 0-255 als Wert benötige, damit 
die Genaugikeit nicht zu hoch und nicht zu niedrig ist.
Und dass ich drei D/A Wandler benötige um die drei Dioden anzusprechen.)

Und eine kleine Frage noch zum Schluss.
Ist es über VHDL genauso einfach, wie mit C++ :
Einfach rot=256 setzten und dann durch eine Schleife grün immer um "1" 
erhöhen?
Dann rot wieder in 1er Schritten auf "0" und das dann mit allen drei 
Farben einmal durch?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Florian R. schrieb:
> Eine einfachere Methode über PWM ist leider nicht erlaubt.
Was ist daran einfacher?
Oder andersrum: wenn dir das mit der PWM leicht fällt, dann mach es erst 
mal so. Anschließend kannst du die Ausgabe dann einfach auf den R2R DAC 
umbauen...

Florian R. schrieb:
> Und eine kleine Frage noch zum Schluss. ...
Die Antwort darauf lautet: Prinzipiell ja, aber du kannst deine C 
Denkweise erst mal KOMPLETT vergessen. Denn die wird dich SOFORT in die 
falsche Richtung führen.
Mein Tipp: lass die LEDs einfach erst mal Blinken. Erst eine, dann Alle, 
dann abwechselnd:
http://www.lothar-miller.de/s9y/archives/80-Hello-World!.html
Denn wenn du dich ohne VHDL und FPGA Kenntnisse sofort die DAC 
Geschichte machst, fällst du auf die Nase. Garantiert.

Florian R. schrieb:
> (Ich weiß bis jetzt, dass ich 8bit, also 0-255 als Wert benötige, damit
> die Genaugikeit nicht zu hoch und nicht zu niedrig ist.
> Und dass ich drei D/A Wandler benötige um die drei Dioden anzusprechen.)
Das ist nicht viel...
Wie sieht die Beschaltung der LEDs aus? Willst du echt einen 8 Bit R2R 
DAC bauen? Evtl. sogar mit 1% Widerständen(*)? Hast du einen Schaltplan?

> Es soll ein Altera DE2 Board mit Cyclon II (EP2C35F672C6N) Prozessor und
> ein R2R Netzwerk benutzt werden. Die Software dafür soll über Quartus II
> umgesetzt werden
Das ist kein Prozessor, sondern ein FPGA. Und du erstellst dafür auch 
keine Software, sondern eine Hardwarebeschreibung (daher kommt das HDL 
in VHDL).

(*)Siehe den Beitrag "R2R-Wandler mit einem PLD"

[Lattice User (Gast)]

Lothar M. schrieb:
> Willst du echt einen 8 Bit R2R
> DAC bauen? Evtl. sogar mit 1% Widerständen(*)?
>
> (*)Siehe den Beitrag "R2R-Wandler mit einem PLD"

Bei allem Respekt, aber der DAC muss nicht viel besser sein als das 
Auge. Und dafür reichen die 1% Widerstände bei weitem aus. Ich bezweifle 
sogar dass man den Fehler auch bei 2% Widerständen überhaupt sieht.

Du hast doch sicher einen Aufbau bei dem du eine LED mit PWM ansteuern 
kannst. Ermittle mal den minimalen Sprung bei halber Helligkeit den du 
wahrnehmen kannst, d.h. 128 -> 128 + n

Auf der anderen Seite hat das Auge einen hohen Dynamikumfang, die 
Sprünge bei kleinen Werten eines 8bit DAC sind deutlich sichtbar, d.h. 
8bit sind zu wenig. 12 bit R2R DAC aufgebaut mit 1% Widerständen wäre 
passend, die Nichtlinearität der LED jetzt mal vernachlässigt.

Bei Audio gilt übrigens die gleiche Argumentation, d.h. 12-14 Bit 
relative Genauigkeit bei 20-24 Bit Dynamikumfang. Reicht dann vielleicht 
auch am Ende der Overtüre zu Tschaikowskis 1812 nicht zu übersteuern.

[Florian R. (florifantasy)]

Hallo,

ich habe nun ein wenig ausprobiert und die angeschlossene LED zum 
blinken gebracht. Sie wird über insg. 18 Pins gesteuert (6x rot, 6x 
blau, 6x grün).
Ich habe mir nun vorgenommen, es nicht auf bit-Ebene zu regeln, da ich 
diese Kenntnis nicht habe und ich auch keine Anleitung dazu gefunden 
habe (falls ihr mir dabei helfen wollt, wäre ich sehr glücklich).
Ansonsten würde ich einfach versuchen alle Kombinationen aus den 18 Pins 
hervorzubringen.
Die einzelnen Pins haben unterschiedliche Helligkeiten, alle zusammen 
100% Helligkeit (nicht linearer Anstieg, wie von euch genannt).
Ich weiß leider nicht, wie ich den Code vereinfachen kann, damit ich 
nicht jede einzelne Möglichkeit aufführen muss. Es wäre schön, wenn ihr 
euch den Code mal ansehen würdet und mir ein Paar Tipps gebt:

    library ieee;
    use ieee.std_logic_1164.all;
    use ieee.numeric_std.all;
   
   entity LED_FARB is
   port( 
   CLOCK_50 : in STD_LOGIC;
   LED_G1 : out STD_LOGIC;
   
   sw0, sw1, sw2, sw3, sw4, sw5, sw6, sw7, sw8, sw9, sw10, sw11, sw12, sw13, sw14 , sw15, sw16, sw17         : in std_logic;
      g0, g1, g2, g3, g4, g5     : out bit; --grün=g blau=b rot=r
      b0, b1, b2, b3, b4, b5     : out bit;
      r0, r1, r2, r3, r4, r5      : out bit
      );
   end LED_FARB;
   
   architecture Behavioral of LED_FARB is
   signal c : integer range 0 to 24999999 := 0; -- 0,5s bei 50MHz fosc
signal x : std_logic:= '0';  
signal y : std_logic:= '1';
signal w : integer range 0 to 12 := 0;

-- neues ding
begin 

  r0 <= '1' when (w = 1) else '0';    b0 <= '1' when (w = 1) else '0';
  r1 <= '1' when (w = 2) else '0';    b1 <= '1' when (w = 2) else '0';
  r2 <= '1' when (w = 3) else '0';    b2 <= '1' when (w = 3) else '0';
  r3 <= '1' when (w = 4) else '0';    b3 <= '1' when (w = 4) else '0';
  r4 <= '1' when (w = 5) else '0';    b4 <= '1' when (w = 5) else '0';
  r5 <= '1' when (w = 6) else '0';    b5 <= '1' when (w = 6) else '0';

  

    


   process begin  
      wait until rising_edge(CLOCK_50); -- warten bis zum nächsten Takt 
      if (c<24999999) then         -- 0…24999999 = 25000000 Takte = 1/2 Sekunde bei 50MHz 
          c <= c+1;         -- wenn kleiner: weiterzählen 
       
      
      else                         -- wenn Zählerende erreicht: 
          c <= 0;                  -- Zähler zurücksetzen 
          x <= not x;              -- und Signal x togglen 
       y <= not y;
      
    
      end if; 
    
    if (c=0)then
      if (w<12) then
       w <= w+1;
       else
       w <= 0;
       end if;
        end if;
    
   end process; 
   LED_G1 <= x;                       -- Signal x an LED ausgeben 
end Behavioral;

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Florian R. schrieb:
> Ich habe mir nun vorgenommen, es nicht auf bit-Ebene zu regeln, da ich
> diese Kenntnis nicht habe
Hört sich nach einer schlüssigen Argumentationskette an.
Man könnte alternativ aber auch einfach mal was Neues lernen...

Florian R. schrieb:
> g0, g1, g2, g3, g4, g5  : out bit;
Zwei Sachen dazu:
Nimm doch statt der vielen einzelnen Bits einfach einen 6 Bit breiten 
Vektor als Ausgang.
Und nimm wie der Rest der Welt statt des bit einen std_logic. Vergiss 
das bit und den bit_vector am Besten gleich ganz.

[Florian R. (florifantasy)]

Hallo,
also ich würde gerne mehr lernen, so war das nicht gemeint.
Ich bin nur nicht so sehr in der Materie drin um es auf so "elegante" 
Weise umzusetzen, denn ich bin nicht ganz eine Woche dabei und war 
eigentlich recht stolz auf meine Ergebnisse. Leider kann ich mit so kurz 
gehaltenen Aussagen auch nicht viel anfangen. Es wäre schön, wenn du mir 
helfen willst, deine Aussagen einmal an einem kurzen Codebeispiel zu 
zeigen, ich denke dass würde Leuten in Zukunft das ganze auch leichter 
machen.

Und nun noch eine Frage zu den Vektoren. Wenn ich 6 verschiedene Pins 
habe und alle unterschiedlich in der Helligkeit sind, wie bilde ich dann 
damit ein gutes Vektorsystem? (Am besten 
1,2,12,3,13,23,123,4,14,24,124,34,134,234,1234,5,15,25,125,35...)
Und dann müsste ich jede einzelne Helligkeit mit jeder der anderen Farbe 
einmal aufleuchten lassen um einen vollen RGB-Farbkreis zu erschaffen.

Es wäre schön, wenn du mir und auch gerne jemand anders etwas helfen 
würde.

[Lattice User (Gast)]

Florian R. schrieb:
>
> Und nun noch eine Frage zu den Vektoren. Wenn ich 6 verschiedene Pins
> habe und alle unterschiedlich in der Helligkeit sind, wie bilde ich dann
> damit ein gutes Vektorsystem? (Am besten
> 1,2,12,3,13,23,123,4,14,24,124,34,134,234,1234,5,15,25,125,35...)
> Und dann müsste ich jede einzelne Helligkeit mit jeder der anderen Farbe
> einmal aufleuchten lassen um einen vollen RGB-Farbkreis zu erschaffen.
>

Um das beantworten zu können, müssen wir den Schaltplan kennen. Ein 
einfaches R2R Netzwerk an den FPGA Pins funktioniert übrigens mit LEDs 
nicht.

[Frank E. (Firma: Q3) (qualidat)]

Zwei wichtige Faktoren aus der Farbenlehre solltest du berücksichtigen, 
unabhängig von der Ausgabemethode (PWM oder analog):

1.) zum Durchlaufen des Spektrums und dem besseren Verstehen, was 
eigentlich Farbe ist, nimm als Basis das HSV-Farbsystem.

Dies trennt in Hue (Farbe auf einem Kreis von 0=Rot immer in 
60-Grad-Schritten über Gelb, Grün, Cyan, Blau bis Magenta bei 300 Grad 
und dann zurück zu Rot bei 360=0 Grad).

Es trennt weiterhin in Saturation (Sättigung, "Reinheit", geht von 
reiner Farbe über "blass" bis neutral, also nicht-farbig) und Value 
(Helligkeit von ganz intensiv bis dunkel/schwarz). So kann man rel. 
problemlos einen bestimmten Farbton vorgeben bzw. sich vorzustellen. Das 
ist so wesentlich einfacher als sich z.B. "R=100, B=50 und G=10" 
vorzustellen!

Um das auf die LEDs auszugeben brauchst du nat. am Ende dann die 
RGB-Werte, dazu nimmst du z.B. die Formel aus Wikipedia oder von hier:

http://www.wisotop.de/vonRGBnachHSV.shtml

2.) das Empfinden des menschlichen Auges ist logarithmisch (glaub 
ungefähr zur Basis 3), nicht linear. Also doppelter Strom durch die LED 
bedeutet noch lange nicht, dass diese auch als doppelt so hell empfunden 
wird. Also sieh in deiner Software vor der Ausgabe je Kanal noch eine 
LUT (look-up-table) zur Kennlinien-Korrektur vor!

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Frank E. schrieb:
> Zwei wichtige Faktoren aus der Farbenlehre solltest du berücksichtigen
Ich glaube fast, dass das zwar korrekt ist, aber himmelweit über das 
simple Ziel hinausschießt.

Lattice User schrieb:
> Ein einfaches R2R Netzwerk an den FPGA Pins funktioniert übrigens mit
> LEDs nicht.
Ich denke ernsthaft: für das Nievau, auf dem wir gerade sind, würde das 
erst mal ausreichen. Die Nichtlinearitäten kann man später klären.

Florian R. schrieb:
> Wenn ich 6 verschiedene Pins habe und alle unterschiedlich in der
> Helligkeit sind, wie bilde ich dann damit ein gutes Vektorsystem?
Nimm wie der Rest der Welt das altbekannte Zweiersystem. Damit lässt 
sich toll arbeiten und jeder versteht es.

> (Am besten 1,2,12,3,13,23,123,4,14,24,124,34,134.......)
Was sagen diese Zahlenkolonnen aus? Welches Bild hast du da im Kopf?

> Wenn ich 6 verschiedene Pins habe und alle unterschiedlich in der
> Helligkeit sind
Zeig doch mal einen Schaltplan. Ohne sowas ist jede weitere Diskussion 
sinnlos. Denn es können 100 vollkommen korrekte Aussagen kommen und du 
kannst trotzdem nicht 1 Einzige davon verwerten.

> Es wäre schön, wenn du mir und auch gerne jemand anders etwas helfen
> würde.
Oft ist es so, dass nicht geholfen wird, weil keiner versteht, was du 
denn eigentlich willst...