Problem bei AC97-Codec Ansteuerung (LM4550)

[Benjamin K. (halunke86)]

Hallo,

ich experimentiere zur Zeit mit dem AC97-Standard. Hierfür verwende ich 
das Digilent-Genesys-Virtex5-Evalboard (mit dem LM4550).
Als erstes wollte ich mir ein Testsignal an der Lautsprecherbuchse 
(genauer gesagt: Headphone) ausgeben lassen. Hierfür setze ich in jedem 
Frame das Master + Headphone Volume auf einen (über Schiebeschalter) 
einstellbaren Wert (dies sind auch die einzigen Einstellungen, welche 
ich in den Registern für den AC97Codec vornehme). Das Testsignal 
schreibe ich dann in Slot3&4 (PCM-Data), sodass an meiner Buchse am Ende 
ein Monosignal entstehen sollte.

Wenn ich nun Kopfhörer an die HP OUT Buchse anschließe, höre ich zwar 
prinzipiell einen Ton (welcher von der Frequenz mit meinem Testsignal 
übereinstimmt und sich auch variieren lässt), dessen Lautstärke sich 
auch dämpfen lässt, jedoch ist dieser sehr sehr leise.

Ich kann aus den oben geschilderten Beobachtungen schließen, dass ich 
mit den Timings richtig liegen sollte (ansonsten käme weder ein Ton noch 
würde ich die Lautstärke regeln können).
Muss ich noch zusätzliche Einstellungen als die oben genannten Treffen 
oder hat jemand eine Idee, was das Verhalten erklären könnte?

Im Anhang habe ich mal noch den VHDL-Code, falls das jemandem 
weiterhilft (bitte nicht wundern falls es an der ein oder anderen Stelle 
etwas unübersichtlich ist, ich experimentiere jetzt schon eine Weile 
damit rum ; da dies meine erstes größeres Projekt in VHDL ist bin ich 
über Hinweise bzgl. des "Programmierstils" auch sehr dankbar)

Vielen Dank schonmal im Voraus.

Gruß Benny

----------------------------------------------------------------------------------
-- Company: 
-- Engineer: 
-- 
-- Create Date:    10:28:53 03/06/2012 
-- Design Name: 
-- Module Name:    ac97controller - Behavioral 
-- Project Name: 
-- Target Devices: 
-- Tool versions: 
-- Description: 
--
-- Dependencies: 
--
-- Revision: 
-- Revision 0.01 - File Created
-- Additional Comments: 
--
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

-- Uncomment the following library declaration if using
-- arithmetic functions with Signed or Unsigned values
--use IEEE.NUMERIC_STD.ALL;

-- Uncomment the following library declaration if instantiating
-- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;

entity ac97controller is
    Port ( clk :           in   STD_LOGIC;
        res_n :        in   STD_LOGIC;
        ac97_bitclk :     in    STD_LOGIC;
           ac97_sdata_in :   in    STD_LOGIC;
        ac97vol :       in   STD_LOGIC_VECTOR(4 downto 0);
           ac97_sync :       out    STD_LOGIC;
           ac97_sdata_out :   out    STD_LOGIC;
           ac97_reset :     out    STD_LOGIC;
        
        sintest_out :     out   STD_LOGIC;
        led1 :         out   STD_LOGIC;
        led2 :         out   STD_LOGIC;
        led3 :         out   STD_LOGIC;
        led4 :         out   STD_LOGIC;
        
        
        cnt_out:         out  integer
        );
end ac97controller;

architecture Behavioral of ac97controller is

type state_type is (reset, slot0, slot1, slot2, slot3, slot4, slotrest);

signal current_state: state_type := reset;
signal sin_test   : std_logic_vector(19 downto 0);

signal bit_cnt   : natural := 0;
signal res_cnt   : natural := 0;
signal sin_cnt    : natural := 0;

signal volcontrol : natural := 0;
signal holddata : std_logic_vector(19 downto 0);


begin
  
  cnt_out <= res_cnt;
  sintest_out <= sin_test(19);

  cold_reset: process (clk, res_n)
  begin
    if (clk'event and clk = '1') then
      if res_n = '0' then
        ac97_reset <= '0';
        res_cnt <= 0;
      elsif res_cnt < 1000 then
        ac97_reset <= '0';
        res_cnt <= res_cnt + 1;
      else
        ac97_reset <= '1';    
      end if;
    end if;
  end process cold_reset;
    
    
  f: process (ac97_bitclk) is
  begin
    holddata <= sin_test;
    if res_n = '0' then
      current_state <= reset;
      ac97_sdata_out <= '0';
      ac97_sync <= '0';
      bit_cnt <= 0;
    elsif ac97_bitclk'event and ac97_bitclk = '1' then
      case current_state is
          when reset =>  current_state <= slot0;
                    ac97_sync <= '1';
                    bit_cnt <= 0;
          when slot0 =>   case bit_cnt is                      --  bit_cnt : 0 .. 15
                      when 0      => ac97_sdata_out <= '1';     -- Valid data bit
                                  ac97_sync <= '1';
                      when 1       => ac97_sdata_out <= '1';     -- Valid control address in slot1 
                                  ac97_sync <= '1';
                      when 2       => ac97_sdata_out <= '1';     -- Valid control data in slot2
                                  ac97_sync <= '1';                    
                      when 3       => ac97_sdata_out <= '1';    -- Valid PCM Data in Slot 3 (Left channel audio)
                                  ac97_sync <= '1';
                      when 4       => ac97_sdata_out <= '1';    -- Valid PCM Data in Slot 4 (Right channel audio)
                                  ac97_sync <= '1';
                      when 15      => ac97_sync <= '0';
                      when others    => ac97_sdata_out <= '0';    -- 
                                  ac97_sync <= '1';
                    end case;
                    if bit_cnt < 15 then 
                      current_state <= slot0;
                    else
                      current_state <= slot1;
                    end if;
          when slot1 =>   if volcontrol = 1 then                    -- !toggler -> master vol. reg
                      case bit_cnt is                        --  bit_cnt : 16 .. 35
                        when 16        => ac97_sdata_out <= '0';     -- write
                        when 22        => ac97_sdata_out <= '1';     -- master volume register 02h
                        when others     => ac97_sdata_out <= '0';
                      end case;
                    elsif volcontrol = 0 then
                      case bit_cnt is                        --  bit_cnt : 16 .. 35
                        when 16        => ac97_sdata_out <= '0';     -- write
                        when 21        => ac97_sdata_out <= '1';     -- headphone volume register 04h
                        when others     => ac97_sdata_out <= '0';
                      end case;
            --        else
            --          case bit_cnt is
            --            when 16         => ac97_sdata_out <= '0';
            --            when 21         => ac97_sdata_out <= '1';
            --            when 23         => ac97_sdata_out <= '1';    -- mono volume register
            --            when others     => ac97_sdata_out <= '0';
            --          end case;
                    end if;
                    if bit_cnt < 35 then 
                      current_state <= slot1;
                    else
                      current_state <= slot2;
                      if volcontrol < 1 then 
                        volcontrol <= volcontrol + 1;
                      end if;
                    end if;                              
          when slot2 => --  if toggler = false then                      --  bit_cnt : 36 .. 55
                    --  ac97_sdata_out <= '0';                    --  unmute + 0dB attention
                    --else
                      case bit_cnt is
                        when 36         => ac97_sdata_out <= '0';    -- unmute
                        when 37        => ac97_sdata_out <= ac97vol(4);
                        when 38        => ac97_sdata_out <= ac97vol(3);
                        when 39        => ac97_sdata_out <= ac97vol(2);
                        when 40        => ac97_sdata_out <= ac97vol(1);
                        when 41        => ac97_sdata_out <= ac97vol(0);
                        when others     => ac97_sdata_out <= '0';  
                      end case;
                    --end if;
                    if bit_cnt < 55 then                     
                      current_state <= slot2;
                    else
                      current_state <= slot3;
--                      toggler <= not toggler;
                    end if;
          when slot3 =>   ac97_sdata_out <= holddata(75 - bit_cnt);        --  bit_cnt : 56 .. 75
                    ac97_sync <= '0';        
                    if bit_cnt < 75 then 
                      current_state <= slot3;
                    else
                      current_state <= slot4;
                    end if;
          when slot4 =>   ac97_sdata_out <= holddata(95 - bit_cnt);        --  bit_cnt : 76 .. 95
                    ac97_sync <= '0';
                    if bit_cnt < 95 then 
                      current_state <= slot4;
                    else
                      current_state <= slotrest;
                    end if;
          when slotrest =>                                   -- bit_cnt : 96 .. 255
                    ac97_sdata_out <= '0';
                    ac97_sync <= '0';
                    if bit_cnt < 255 then 
                      current_state <= slotrest;
                    else
                      ac97_sync <= '1';
                      current_state <= slot0;
                    end if;
      end case;
      
      if current_state /= reset and res_n = '1' and bit_cnt < 255 then
        bit_cnt <= bit_cnt + 1;
      else
        bit_cnt <= 0;
      end if;
    end if;
  end process;

  --Testsignal
  process(ac97_bitclk) is
  begin
    if ac97_bitclk'event and ac97_bitclk = '1' then
      if sin_cnt <= 12288 then
        sin_test <= "11111111111111111100";
        sin_cnt <= sin_cnt + 1;
      elsif sin_cnt < 24576 then
        sin_test <= "00000000000000000000";
        sin_cnt <= sin_cnt + 1;
      else
        sin_cnt <= 0;
      end if;
    end if;
  end process;

end Behavioral;

[M. J. (manfred-64)]

Hi,

nur mal so, da man sich öfters mal bei den einfacheren Dingen vertut.
Bist Du sichre das Du die HP und nicht ne LIN Buchse erwischt hast?

[Benjamin K. (halunke86)]

Jup, bin mir sicher....
Auch die Kopfhörer habe ich als Fehlerquelle ausschließen können, wenn 
ich hochohmig mit dem Oszilloskop messe kann ich kein Signal - mal 
abgesehn vom Rauschen - erkennen (interessant dass ich überhaupt etwas 
höre ;) )

Gruß Benny

[Benjamin K. (halunke86)]

Oh, mein letzter Beitrag klingt ein wenig wirr, wollte schreiben dass 
ich die Kopfhörer als Fehlerquelle ausschließen kann und dass es mich 
wundert, dass ich mit dem Oszilloskop kein Signal messen kann ;)

[Stefan H. (Firma: dm2sh) (stefan_helmert)]

Benjamin K. schrieb:
> sehr sehr leise

Benjamin K. schrieb:
> 11111111111111111100

Benjamin K. schrieb:
> 00000000000000000000

http://de.wikipedia.org/wiki/Zweierkomplement

[Benjamin K. (halunke86)]

Hallo Stefan,

deine Antwort klang so vielversprechend, jedoch bekommme ich mit 
"00000000000000000000" und "00000000000000000100" immer noch keinen 
lauteren Ton heraus...
Werden die PCM-Daten eigentlich als Signed oder Unsigned interpretiert? 
Habe dazu bisher auch noch keine fundierte Aussage gefunden...(ich habe 
es auch schon mit den Werten "00000000000000000100" und 
"10000000000000000100" versucht, jedoch auch ohne Erfolg...)

Interessant ist auch, dass in der Codec-Beschreibung kein Wort vom 
Zweierkomplement gemacht wird und ich erst nach deinem Hinweis erste 
Suchergebnisse gefunden habe, wo dies erwähnt wird....

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

Benjamin K. schrieb:

 f: process (ac97_bitclk) is
   begin
     holddata <= sin_test;  
     if res_n = '0' then
             :
     elsif ac97_bitclk'event and ac97_bitclk = '1' then

Was fehlt da wohl alles in der Sensitivliste?

Benjamin K. schrieb:
> deine Antwort klang so vielversprechend, jedoch bekommme ich mit
> "00000000000000000000" und "00000000000000000100" immer noch keinen
> lauteren Ton heraus...
Funktioniert die Kommunikastion grundsätzlich?
Was sagt denn deine Simulation?

BTW:
Auch wenn dieses Design mal läuft, wirst du immer wieder mal Prbleme 
bekommen, weil da munter Signale über Taktdomänengrenzen hin+her 
verdrahtet sind...
Woher kommen diese Takte?

Und schon der asynchrone Reset kann dazu führen, dass das Design nach 
dem Start mal läuft und mal nicht...

[Benjamin K. (halunke86)]

Dies liegt daran dass ich mit 2 verschiedenen Clocks arbeiten muss. 
Während eines Resets bzw. nach dem Einschalten des Boards muss der 
AC97Codec erst einmal "gebootet" werden, weshalb ich hier über den 
FPGA-Clk arbeite.
Danach stellt der Codec einen eigenen Bitclk zur Verfügung, mit welchem 
ich dann arbeite, um die Frames zu übertragen...
Du hast natürlich recht dass meine Sensivity-Liste unvollständig ist, 
ich habe viel herumexperimentiert weshalb noch das ein oder andere 
Artefakt im Code vorhanden ist...
Muss aber zu meiner Verteidigung sagen dass sich bisher keine 
Auffälligkeiten nach einem manuellen Reset gezeigt haben....

Gruß Benny

[ergher (Gast)]

> jedoch bekommme ich mit "00000000000000000000" und "00000000000000000100"
> immer noch keinen lauteren Ton heraus...

kein Wunder, liegt ja auch nicht besonders weit auseinander - Versuch 
mal 000000000000 und 011111111111111...

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

Benjamin K. schrieb:
> Dies liegt daran dass ich mit 2 verschiedenen Clocks arbeiten muss.
Wenn du das WEISST, dann kannst du ja was gegen potentielle Fehler tun 
und solche Taktdomänenübergänge per Synchronisation entschärfen.

> Muss aber zu meiner Verteidigung sagen dass sich bisher keine
> Auffälligkeiten nach einem manuellen Reset gezeigt haben....
Ja, irgendwann ist immer das erste Mal...  ;-)

Ich kenne deinen Baustein nicht, und weiß daher auch nicht, was 
tatsächlich klemmt, aber weil du gefragt hast:
Benjamin K. schrieb:
> bin ich über Hinweise bzgl. des "Programmierstils" auch sehr dankbar)
In diesem letzten Prozess sind die Zähler in den if-Abfragen ungünstig 
aufgehoben. Denn wenn du in 4 Wochen noch ein if dazuhängst, aber 
vergisst, den Zähler mit reinzubauen, dann belibt der stehen. Besser 
wäre es, den Zähler auf jeden Fall hochzuzählen, und bei Bedarf 
zurückzusetzen:

  process(ac97_bitclk) is
  begin
    if ac97_bitclk'event and ac97_bitclk = '1' then
      sin_cnt <= sin_cnt + 1;  -- auf jeden Fall beim Takt hochzählen
      if sin_cnt <= 12288 then
        sin_test <= "11111111111111111100";
      elsif sin_cnt < 24576 then
        sin_test <= "00000000000000000000";
      else
        sin_cnt <= 0;
      end if;
    end if;
  end process;

[Benjamin K. (halunke86)]

ergher schrieb:
>> jedoch bekommme ich mit "00000000000000000000" und "00000000000000000100"
>> immer noch keinen lauteren Ton heraus...
>
> kein Wunder, liegt ja auch nicht besonders weit auseinander - Versuch
> mal 000000000000 und 011111111111111...

Wenn der Codec es als Zweierkomplement interpretiert, habe ich einmal 
"0..0" und einmal "11111111111111111011" + 1 = "1111111111111111100" 
(also wenn ich es als VZ-lose Zahl interpretiere)
So nah beieinander liegen die Werte doch gar nicht....


@Lothar:

thx für die Tips, werde sie im Hinterkopf behalten ;)

Gruß Benny

[Benjamin K. (halunke86)]

So,
ich habe inzwischen einen Fehler entdecken können:
Bei den Adressregistern (Slot1) habe ich mich - was meinen bitcnt angeht 
- um 1 Bit vertan (siehe unten). Wenn ich diesen Fehler jedoch 
korrigiere, höre ich überhaupt nichts mehr.
Kann mir jemand mal die Bereiche des bitcnt mit den jeweiligen Zuständen 
bestätigen (also slot0 geht von 0..15, slot1 von 16..35 usw) bzw. 
widerlegen?

Gruß Benny

Anhang (zu den Adress-Reg's):
Das Master Vol. Register hat die Adresse 02h = "00000010", das Headphone 
Vol. Reg die Adresse 04h = "00000100". Das erste Bit in Slot1 gibt an, 
ob gelesen (=1) oder geschrieben(=0) wird.
Will man also ins Master-Vol-Reg schreiben, sieht slot1 folgendermaßen 
aus:
"00000001000000000000" (bitcnt = 23)
Für das HP-Vol-Reg ergibt sich "00000010000000000000" (bitcnt = 22)

[Benjamin K. (halunke86)]

So, neues Statusupdate, habe den Fehler nun endgültig gefunden:
Es gibt noch ein PCM Out Volume Register, welches mir bisher nicht 
aufgefallen ist, da es in der Register Map unter "Input Volume" 
beschrieben wird. Dieses ist defaultmäßig auf Mute, weshalb der Testton 
so stark gedämpft klang (interessant dass überhaupt ein Ton 
herausgegeben wird)...
An dieser Stelle möchte ich noch die Aussage meines letzten Beitrags 
korrigieren, habe nicht berücksichtigt dass der Adressvektor die Länge 7 
hat. Aus diesem Grund ist die Zuordnung aus dem ersten Beispiel doch 
korrekt gewesen.

Abschließend noch einmal der überarbeitete Code, welcher mit Sicherheit 
programmiertechnisch noch nicht einwandfrei ist, jedoch ein 
funktionierendes Ergebnis erbringt.

Vielen Dank nochmal an alle, die hier mitdiskutiert haben.

----------------------------------------------------------------------------------
-- Company: 
-- Engineer: 
-- 
-- Create Date:    10:28:53 03/06/2012 
-- Design Name: 
-- Module Name:    ac97controller - Behavioral 
-- Project Name: 
-- Target Devices: 
-- Tool versions: 
-- Description: 
--
-- Dependencies: 
--
-- Revision: 
-- Revision 0.01 - File Created
-- Additional Comments: 
--
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

-- Uncomment the following library declaration if using
-- arithmetic functions with Signed or Unsigned values
use IEEE.NUMERIC_STD.ALL;

-- Uncomment the following library declaration if instantiating
-- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;

entity ac97controller is
    Port ( clk :           in   STD_LOGIC;
        res_n :        in   STD_LOGIC;
        ac97_bitclk :     in    STD_LOGIC;
           ac97_sdata_in :   in    STD_LOGIC;
        ac97vol :       in   STD_LOGIC_VECTOR(4 downto 0);
           ac97_sync :       out    STD_LOGIC;
           ac97_sdata_out :   out    STD_LOGIC;
           ac97_reset :     out    STD_LOGIC;
        
        sintest_out :     out   STD_LOGIC;
        led1 :         out   STD_LOGIC;
        led2 :         out   STD_LOGIC;
        led3 :         out   STD_LOGIC;
        led4 :         out   STD_LOGIC
        );
end ac97controller;

architecture Behavioral of ac97controller is

type state_type is (reset, slot0, slot1, slot2, slot3, slot4, slotrest);

signal current_state: state_type := reset;
signal sin_test   : std_logic_vector(19 downto 0);

signal bit_cnt   : natural range 0 to 255;
signal res_cnt   : natural := 0;
signal sin_cnt    : natural := 0;

signal volcontrol : natural := 0;

signal volume : std_logic_vector(15 downto 0);

constant REG_MASTERVOL : std_logic_vector(6 downto 0) := "0000010";
constant REG_HPVOL : std_logic_vector(6 downto 0) := "0000100";
constant REG_PCMOUTVOL : std_logic_vector(6 downto 0) := "0011000";
constant PCMOUTVOL : std_logic_vector (15 downto 0) := "0001111100011111";

-- VZ-behaftet, Zweierkomplement
constant HIGHVAL   : std_logic_vector(19 downto 0) := "01111111111111111100";     -- Zweierkomplement: "1000000000000000100"
constant LOWVAL   : std_logic_vector(19 downto 0) := "00000000000000000000";    -- Zweierkomplement: "0111111111111111000"
--constant LOWVAL   : std_logic_vector(19 downto 0) := "00000000000000000000";

-- nicht VZ-behaftet, Zweierkomplement
--constant HIGHVAL   : std_logic_vector(19 downto 0) := "00000000000000000000";
--constant LOWVAL   : std_logic_vector(19 downto 0) := "00000000000000000100";

-- nicht VZ-behaftet
--constant HIGHVAL   : std_logic_vector(19 downto 0) := "00000000000000000000";
--constant LOWVAL   : std_logic_vector(19 downto 0) := "11111111111111111100";


begin

  volume <= "000" & ac97vol & "000" & ac97vol;

  cold_reset: process (clk, res_n)
  begin
    if (clk'event and clk = '1') then
      if res_n = '0' then
        ac97_reset <= '0';
        res_cnt <= 0;
      elsif res_cnt < 1000 then
        ac97_reset <= '0';
        res_cnt <= res_cnt + 1;
      else
        ac97_reset <= '1';    
      end if;
    end if;
  end process cold_reset;
    
    
  f: process (ac97_bitclk, res_n) is
  begin
    if res_n = '0' then
      current_state <= reset;
      ac97_sdata_out <= '0';
      ac97_sync <= '0';
      bit_cnt <= 0;
      sin_cnt <= 0;
    elsif ac97_bitclk'event and ac97_bitclk = '1' then
      case current_state is
          when reset =>  ac97_sync <= '1';
                    bit_cnt <= 0;
                    sin_cnt <= 0;
                    if res_cnt < 1000 then
                      current_state <= reset;
                    else
                      current_state <= slot0;
                    end if;
          when slot0 =>   case bit_cnt is                      --  bit_cnt : 0 .. 15
                      when 0      => ac97_sdata_out <= '1';     -- Valid data bit
                                  ac97_sync <= '1';
                      when 1       => ac97_sdata_out <= '1';     -- Valid control address in slot1 
                                  ac97_sync <= '1';
                      when 2       => ac97_sdata_out <= '1';     -- Valid control data in slot2
                                  ac97_sync <= '1';                    
                      when 3       => ac97_sdata_out <= '1';    -- Valid PCM Data in Slot 3 (Left channel audio)
                                  ac97_sync <= '1';
                      when 4       => ac97_sdata_out <= '1';    -- Valid PCM Data in Slot 4 (Right channel audio)
                                  ac97_sync <= '1';
                      when 15      => ac97_sync <= '0';
                      when others    => ac97_sdata_out <= '0';    -- 
                                  ac97_sync <= '1';
                    end case;
                    if bit_cnt < 15 then 
                      current_state <= slot0;
                    else
                      current_state <= slot1;
                    end if;
          when slot1 =>   if bit_cnt = 16 then                        -- bitcnt : 16..35
                      ac97_sdata_out <= '0';                    -- write
                    elsif bit_cnt < 24 then
                      if volcontrol = 0 then                    -- pcmout volume register
                        ac97_sdata_out <= REG_PCMOUTVOL(23-bit_cnt);    
                      elsif volcontrol = 1 then                  -- master volume register
                        ac97_sdata_out <= REG_MASTERVOL(23-bit_cnt);    
                      else                                -- headphone volume register
                        ac97_sdata_out <= REG_HPVOL(23-bit_cnt);      
                      end if;
                    else
                      ac97_sdata_out <= '0';
                    end if;
                    
                    if bit_cnt < 35 then 
                      current_state <= slot1;
                    else
                      current_state <= slot2;
                    end if;                              
          when slot2 =>  if bit_cnt < 52 then
                      if volcontrol = 0 then
                        ac97_sdata_out <= PCMOUTVOL(52 - bit_cnt);
                      else
                        ac97_sdata_out <= volume(52 - bit_cnt);        -- bitcnt : 36 .. 55  
                      end if;
                    else
                      ac97_sdata_out <= '0';
                    end if;
                    if bit_cnt < 55 then                     
                      current_state <= slot2;
                    else
                      if volcontrol < 2 then 
                        volcontrol <= volcontrol + 1;
                      else 
                        volcontrol <= 1;
                      end if;
                      current_state <= slot3;
                    end if;
          when slot3 =>  ac97_sync <= '0';                          --  bit_cnt : 56 .. 75
                    if sin_cnt < 24 then
                      ac97_sdata_out <= HIGHVAL(75 - bit_cnt);  
                    else
                      ac97_sdata_out <= LOWVAL(75 - bit_cnt);
                    end if;
                    
                    if bit_cnt < 75 then 
                      current_state <= slot3;
                    else
                      current_state <= slot4;
                    end if;
          when slot4 =>   ac97_sync <= '0';                          --  bit_cnt : 76 .. 95
                    if sin_cnt < 24 then
                      ac97_sdata_out <= HIGHVAL(95 - bit_cnt);        
                    else
                      ac97_sdata_out <= LOWVAL(95 - bit_cnt);        
                    end if;
                    
                    if bit_cnt < 95 then 
                      current_state <= slot4;
                    else
                      if sin_cnt < 48 then
                        sin_cnt <= sin_cnt + 1;
                      else
                        sin_cnt <= 0;
                      end if;
                      current_state <= slotrest;
                    end if;
          when slotrest =>                                   -- bit_cnt : 96 .. 255
                    ac97_sdata_out <= '0';
                    ac97_sync <= '0';
                    if bit_cnt < 255 then 
                      current_state <= slotrest;
                    else
                      ac97_sync <= '1';
                      current_state <= slot0;
                    end if;
      end case;
      
      if current_state /= reset and res_n = '1' and bit_cnt < 255 then
        bit_cnt <= bit_cnt + 1;
      else
        bit_cnt <= 0;
      end if;
    end if;
  end process;

    
  process(clk) is
  begin 
    case current_state is
      when reset =>   led1 <= '1';
                led2 <= '0';
                led3 <= '0';
                led4 <= '0';
      when slot0 => 
                led1 <= '0';
                led2 <= '1';
                led3 <= '0';
                led4 <= '0';
      when slot1 =>   led1 <= '0';
                led2 <= '0';
                led3 <= '1';
                led4 <= '0';
      when slot2 =>   led1 <= '0';
                led2 <= '0';
                led3 <= '0';
                led4 <= '1';
      when others => led1 <= '0';
                led2 <= '0';
                led3 <= '0';
                led4 <= '0';
    end case;
  end process;

end Behavioral;

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

Benjamin K. schrieb:

 cold_reset: process (clk, res_n)
   begin
     if (clk'event and clk = '1') then

res_n ist in der Sensitivliste nicht nötig.
Dieser Prozess ist incl. Reset komplett synchron.

Warum hast du das beim zweiten Prozess nicht auch so gemacht?

  process(clk) is
  begin 
    case current_state is
      when reset =>   led1 <= '1';

clk ist in der Sensitivliste nicht nötig, weil er im Prozess gar nicht 
verwendet wird. Korrekterweise müsste aber current_state da rein.
Aber: zum Glück macht das der Synthesizer automatisch...  ;-)
Nur: die Hardware und die Simulation passen nicht zueinander... :-o

[Benjamin K. (halunke86)]

Lothar Miller schrieb:
> Warum hast du das beim zweiten Prozess nicht auch so gemacht?

In dem Moment, wo der Reset-Button gedrückt wird, hört mein Bitclk auf 
und wird auf low gezogen. Ist jetzt der Bitclk just im Moment des Resets 
auf '0', wird der Prozess doch nicht darauf reagieren, oder?

Gruß Benny

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

Benjamin K. schrieb:
> In dem Moment, wo der Reset-Button gedrückt wird
Brauchst du tatsächlich einen Reset-Knopf?
Und wenn: kannst du mit dem nicht auch gleich das FPGA neu laden?
Dann wäre nämlich ohne Reset alles im Urzustand...

Lies mal den Beitrag "Xilinx und die Resets"
Und das darin erwähnte WP272 von Xilinx.

[Rolf S. (audiorolf)]

Ich habe auch den LM4550 drauf und musste feststellen, dass das ein 
ziemliches Tier ist. Kann alles bis zum 3D Sound ist aber nicht so 
einfach zu programmieren. Momentan hapert es auch ein bischen an meinem 
Verständnis für die zu übertragenden Audiodaten:

Laut Beschreibung handelt es sich um PCM Daten. Das heisst für mich, ich 
muss meinen analogen Datenstrom (kommt bei mir mit 96kHz) erst noch in 
PCM wandeln, um ihn in die Slots einzufügen. (?)

Abgesehen davon, dass ich keinen Core dafür habe, verwirrt mich die 
Aussage in diesem Thema, dass es / ob es sich um signed/unsigned PCM 
handelt:

Beitrag "Re: AC97 Audio Codec, Ansteuerung mit VHDL"

Leider finde ich auf der dort verlinkten Seite keinen Beispiel-Code.

Etwas dazu gibt es wohl noch hier:
Beitrag "AC97-VHDL-Sourcecode"
Beitrag "Richtige Ansteuerung des AC97-Chips?"

aber auch das ist nicht so durchsichtig.

Warum wird der Codec eigentlich überhaupt mit PCM gefahren, statt mit 
seriellen digitalen Daten?

[Hobbymusiker (Gast)]

> Laut Beschreibung handelt es sich um PCM Daten. Das heisst für mich, ich
> muss meinen analogen Datenstrom (kommt bei mir mit 96kHz) erst noch in
> PCM wandeln, um ihn in die Slots einzufügen. (?)
Das sollte eigentlich Aufgabe des Codes sein, meine ich. PCM ist doch 
1-Bit Daten und beschrieben wird sicher parallel.

> Abgesehen davon, dass ich keinen Core dafür habe, verwirrt mich die
> Aussage in diesem Thema, dass es / ob es sich um signed/unsigned PCM
> handelt
http://www.wiki.multimedia.cx/index.php?title=PCM

[pcm (Gast)]

Hallo,

wenn bei diesem Codec PCM das hier 
(http://de.wikipedia.org/wiki/Puls-Code-Modulation) ist, dann frage ich 
mich, wo denn bitteschön das Problem ist? Das ist ja dann einfacher wie 
ein serieller Datenstrom (da keine Bit-Alignment Detektion erforderlich 
ist).

Hobbymusiker schrieb:
> (kommt bei mir mit 96kHz)

Das heißt, dass du mit 96 KHz nach der AD-Wandlung, also alle ~10,417us, 
einen n bit breiten Wert von deinem Audiosignal bekommst. Dieses Signal 
muss du nach meinem Verständnis in einem Slot vom AC-LINK-Interface 
packen und fertig. Die AC-LINK Schnittstelle scheint mir ein 
deterministisches Verhalten zu haben, also es sendet nacheinander immer 
diesselbe Information in einer festen Reihenfolge in einer festen 
Frequenz. (Keine Garantie auf Richtigkeit, da ich das Datenblatt nur 
überflogen habe und es selber nocht nicht implementiert habe). Das 
schreit förmlich nach einer Lösung mit einer FSM!

Grüße

[Hobbyorganist (Gast)]

pcm schrieb:
> Hobbymusiker schrieb:
>> (kommt bei mir mit 96kHz)
Nur der Vollständigkeit halber:
Ich hatte das nicht geschrieben sondern nur zitiert.

> Das heißt, dass du mit 96 KHz nach der AD-Wandlung, also alle ~10,417us,
> einen n bit breiten Wert von deinem Audiosignal bekommst.
Auch hier nur eine kleine Anmerkung:
Der Codec arbeit mit wesentlich höherem Takt, als die Samplerate und 
liefert alles seriell ab.



> Die AC-LINK Schnittstelle scheint mir ein
> deterministisches Verhalten zu haben, also es sendet nacheinander immer
> diesselbe Information in einer festen Reihenfolge in einer festen
> Frequenz.
Der Codec liefert ein Synch Signal, das die Position der Bits = Slots 
angibt.

Die Frage von Rolf war aber wohl die nach der Art der Daten. Aus meiner 
Sicht muss man da nichts wandeln sondern Daten seriell in die slots 
einfügen.

[Rolf S. (audiorolf)]

Hobbyorganist schrieb:
> Die Frage von Rolf war aber wohl die nach der Art der Daten. Aus meiner
> Sicht muss man da nichts wandeln sondern Daten seriell in die slots
> einfügen.
So scheint es zu sein, und dann machte auch die Fragestellung nach dem 
signed wieder Sinn. Bin jetzt das Dokument nochmals durchgegangen und 
finde immer noch nichts. Momentan tönt es sehr nach Übersteuerung.

[Lattice User (Gast)]

Rolf S. schrieb:
> Hobbyorganist schrieb:
>> Die Frage von Rolf war aber wohl die nach der Art der Daten. Aus meiner
>> Sicht muss man da nichts wandeln sondern Daten seriell in die slots
>> einfügen.
> So scheint es zu sein, und dann machte auch die Fragestellung nach dem
> signed wieder Sinn. Bin jetzt das Dokument nochmals durchgegangen und
> finde immer noch nichts. Momentan tönt es sehr nach Übersteuerung.

Könnte der Unterschied zwischen Offsetcodierung und 2er Komplement sein. 
Invertiere mal das MSB.

[Tux(Programmierer) (Gast)]

Lothar Miller schrieb:
> Benjamin K. schrieb:
>> Dies liegt daran dass ich mit 2 verschiedenen Clocks arbeiten muss.
> Wenn du das WEISST, dann kannst du ja was gegen potentielle Fehler tun
> und solche Taktdomänenübergänge per Synchronisation entschärfen.
>
>> Muss aber zu meiner Verteidigung sagen dass sich bisher keine
>> Auffälligkeiten nach einem manuellen Reset gezeigt haben....
> Ja, irgendwann ist immer das erste Mal...  ;-)
>
> Ich kenne deinen Baustein nicht, und weiß daher auch nicht, was
> tatsächlich klemmt, aber weil du gefragt hast:
> Benjamin K. schrieb:
>> bin ich über Hinweise bzgl. des "Programmierstils" auch sehr dankbar)
> In diesem letzten Prozess sind die Zähler in den if-Abfragen ungünstig
> aufgehoben. Denn wenn du in 4 Wochen noch ein if dazuhängst, aber
> vergisst, den Zähler mit reinzubauen, dann belibt der stehen. Besser
> wäre es, den Zähler auf jeden Fall hochzuzählen, und bei Bedarf
> zurückzusetzen:
>

>   process(ac97_bitclk) is
>   begin
>     if ac97_bitclk'event and ac97_bitclk = '1' then
>       sin_cnt <= sin_cnt + 1;  -- auf jeden Fall beim Takt hochzählen
>       if sin_cnt <= 12288 then
>         sin_test <= "11111111111111111100";
>       elsif sin_cnt < 24576 then
>         sin_test <= "00000000000000000000";
>       else
>         sin_cnt <= 0;
>       end if;
>     end if;
>   end process;
>

Schreib den mal um und zwar so hier wie folgt:

process(ac97_bitclk) is
  begin
    if ac97_bitclk'event and ac97_bitclk = '1' then
      sin_cnt <= sin_cnt + 1;  -- auf jeden Fall beim Takt hochzählen
      if sin_cnt <= 12233 then
        sin_test <= "11101110111111001100";
      elsif sin_cnt < 24576 then
        sin_test <= "00000100100000010001";
      else
        sin_cnt <= 1;
      end if;
    end if;
  end process;

Nun erscheint dein Lautsärkewert in abgewandelter Prozessstruktur und du 
kannst die Laustsärke bis  hochdrehen..

Ist aus änlichem Projekt, aber selber Quellcode.

Tux

[Rolf S. (audiorolf)]

Ich habe jetzt meinen Codec aktiv und es ist in der Tat signed integer, 
was er haben will. Alles andere produziert Störung. Ich habe aber ein 
neues Problem:

Bevor ich meinen Ausgang auf den Codec ausgebe, führe ich noch eine 
Multilpikation mit 16 Bit durch und den Ausgangs zu skalieren. Die 
Lautstärke lässt sich damit wie erwartet eistellen, jedoch habe ich den 
bemerksenswerten Effekt, dass additiv zum Klang ein kleines Sirren hinzu 
tönt, das in der Tonhöhe mit der Lautstärke korreliert ist: Je höher die 
Luatstärkeeinstellung, desto höher (nicht lauter) ist der Störton.

Was könnte das sein?

Die Multiplikation sieht in etwa so aus:

ausgang_temp <= std__logic_vector (signed(quelle) * signed (ampli));

ausgang <= ausgang_temp(31 downto 16);

ampli ist dabei immer positiv zwischen 1024 und 32767.
quelle ist immer zwischen -32499 und 32499

Einen Üerlauf kann es ja nicht geben. Woher kommt das?

In der Simulation ist nichts Ungewähnliches zu erblicken.