отрубил я always @(negedge AUD_DACLRCK)
begin
audio_outR <= audio_inR;
if (TestDevR == 1024)
begin
TestDevR=0;
if (audio_inR <= 65000)
begin
Data_R <= audio_inR;
if (Data_R >=64000) Level_R = 16'b1111111111111111; else
if (Data_R >=32768) Level_R = 16'b0111111111111111; else
if (Data_R >=16384) Level_R = 16'b0011111111111111; else
if (Data_R >=8192) Level_R = 16'b0001111111111111; else
if (Data_R >=4096) Level_R = 16'b0000111111111111; else
if (Data_R >=2048) Level_R = 16'b0000011111111111; else
if (Data_R >=1024) Level_R = 16'b0000001111111111; else
if (Data_R >=512) Level_R = 16'b0000000111111111; else
if (Data_R >=256) Level_R = 16'b0000000011111111; else
if (Data_R >=128) Level_R = 16'b0000000001111111; else
if (Data_R >=64) Level_R = 16'b0000000000111111; else
if (Data_R >=32) Level_R = 16'b0000000000011111; else
if (Data_R >=16) Level_R = 16'b0000000000001111; else
if (Data_R >=8) Level_R = 16'b0000000000000111; else
if (Data_R >=4) Level_R = 16'b0000000000000011; else
if (Data_R >=2) Level_R = 16'b0000000000000001;
end
end else TestDevR = TestDevR+1;
end

Хз что там валит на максимальном уровне, может дискрет.. Них не понимаю так как не понимаю как сделать отладку в месте передачи параметров с звукоухи..

В общем два старших бита "выдавают херню куюто" неизвестного происхождения из выше стоящего выражения я этих биты услал примитивным образом.. Разберусь когда с записи получу файл, я думаю что то генерит а быстрее всего IMHO естесно постоянка по входу в зашкале в одну сторону.. Пока других мыслей нет

вот работа измерителя уровня http://doris.kiev.ua/RS/UKV_001/AlteraDE3/Sound/_P1010312.AVI

вот одно я только не пойму своей прогой я сделал детектор АМ по пиковому уровню, а как же отрицательная сторона сигнала, да и вообще что я в амплитуде сравнил..

объясните пожалуйста как в звуковых картах компьютеров в 16 бит укладываются данные после АЦП?
65534/2 это ноль?

Не знаю как там в звуковухах принято, но скорее всего либо постоянка есть либо в дополнительном коде.

petr0v У меня такое ощущение что положительной полупериод передается от ноля до 32768 а отрицательный от 65535 до 32768. Может и действительно идет в дополнительном коде в знаке..

RadioKoteg
Может так:

http://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%80%D0%B0%D1%82%D0%BD%D1%8B%D0%B9_%D0%BA%D0%BE%D0%B4

john_qkk похоже на то что


«положительный нуль» 00000000_00000000 и «отрицательный нуль» 11111111_11111111

Положительная полу волна от 00000000_00000000 до 01111111_11111111 и отрицательная от
11111111_11111111 до 10000000_00000000, самый левый бит указатель на 0-положительная, 1-отрицательная, отрицательная в инвертированном числе. Это догадки по отладке, на досуге напишу проверочный код для окончательного убеждения.

В обычных звуковухах 16 бит = -32768..32767, нуль в середине (всего 65535 значений амплитуды), как здесь не пойму, если формат без знака, достаточно от 65535 отнять 32768 и получится нормальный формат, с нулем в середине.
Имхо, нужно написать две функции, для преобразования этих двоичных 16'bххххх... в десятичное 16 бит (с нулем в середине) число и обратно, потом можно с ним работать.
Главное понять, где в устройстве реальный нуль, ошибка на единицу здесь всегда вызывает непредсказуемые последствия.
з.ы.
Абсолютных значений, более 32767 ( abs(-32768) ), лучше никогда не допускать и считать, как "полный зашкал".
Для проверки перевода BIN/DEC, можно использовать обычный калькулятор, встроенный в Windows, в инженерном режиме.

Programmist да действительно с самого лева знаковый бит, и когда единица то значит это минус, и еще все в инверсе.

вышло так:






wire [15:0] audio_inL, audio_inR;
reg [15:0] audio_outL,audio_outR;

reg [15:0] Level_R;
reg [15:0] Level_L;
reg [15:0] Data_R;
reg [15:0] Data_L;
reg [32:0] TestDevL=0;
reg [32:0] TestDevR=0;

always @(posedge AUD_DACLRCK)
begin
audio_outL <= audio_inL;
if (TestDevL == 1024) // делитель каждий 1024 отсчет, это так пока чтобы не гонять за зря,
begin
TestDevL=0;
if ((audio_inL >> 15) == 0) //проверяем самый левый бит если ноль значит позитивная часть сигнала
begin
Data_L <= audio_inL;
//таблица конвертации уровней
if (Data_L >=32768) Level_L = 16'b0111111111111111; else
if (Data_L >=16384) Level_L = 16'b0011111111111111; else
if (Data_L >=8192) Level_L = 16'b0001111111111111; else
if (Data_L >=4096) Level_L = 16'b0000111111111111; else
if (Data_L >=2048) Level_L = 16'b0000011111111111; else
if (Data_L >=1024) Level_L = 16'b0000001111111111; else
if (Data_L >=512) Level_L = 16'b0000000111111111; else
if (Data_L >=256) Level_L = 16'b0000000011111111; else
if (Data_L >=128) Level_L = 16'b0000000001111111; else
if (Data_L >=64) Level_L = 16'b0000000000111111; else
if (Data_L >=32) Level_L = 16'b0000000000011111; else
if (Data_L >=16) Level_L = 16'b0000000000001111; else
if (Data_L >=8) Level_L = 16'b0000000000000111; else
if (Data_L >=4) Level_L = 16'b0000000000000011; else
if (Data_L >=2) Level_L = 16'b0000000000000001;
end else // иначе это негативная часть синусоиды
begin
Data_L <= audio_inL; // передаем их wire в регистр
Data_L<= (Data_L ^ 16`b01111111_11111111); // переварачиваем вверх тормашками(инверсия)
if (Data_L >=32768) Level_L = 16'b0111111111111111; else
if (Data_L >=16384) Level_L = 16'b0011111111111111; else
if (Data_L >=8192) Level_L = 16'b0001111111111111; else
if (Data_L >=4096) Level_L = 16'b0000111111111111; else
if (Data_L >=2048) Level_L = 16'b0000011111111111; else
if (Data_L >=1024) Level_L = 16'b0000001111111111; else
if (Data_L >=512) Level_L = 16'b0000000111111111; else
if (Data_L >=256) Level_L = 16'b0000000011111111; else
if (Data_L >=128) Level_L = 16'b0000000001111111; else
if (Data_L >=64) Level_L = 16'b0000000000111111; else
if (Data_L >=32) Level_L = 16'b0000000000011111; else
if (Data_L >=16) Level_L = 16'b0000000000001111; else
if (Data_L >=8) Level_L = 16'b0000000000000111; else
if (Data_L >=4) Level_L = 16'b0000000000000011; else
if (Data_L >=2) Level_L = 16'b0000000000000001;
end
end else TestDevL = TestDevL+1;
end

assign LEDR[15:0] = Level_L; // в Level_L уровень сигнала

в звуковой карте WOLFSON WM8731 первые 4 бита чего то блуждают с специфичным скрежетом как при некачественном питании.. Вот незадача блин..
Присутствует в обоих каналах, по отрицательному уровню.

Не перевернуло XOR..

самого лева знаковый бит
Странная какая-то запись, я таких не встречал, обычно 65535 = 1111111111111111 (16 бит = 16 единиц), непонятно, зачем там так все перевернули, когда знаков (бит) вполне хватает, например:
16'b0111111111111111 = 32767. Я асегда калькулятором такие вещи проверяю.
Возможно, вот так надо:

Data_L:= Data_L + 32767; //Приводим все к положительным числам

if Data_L >= 65535 then
begin
Level_L = 16'b0111111111111111;
Exit;
end;

if Data_L >= 32767 then
begin
Level_R = 16'b0111111111111111;
Exit;
end;

if Data_L >= 16383 then
begin
Level_R = 16'b0011111111111111;
Exit;
end;
...

Programmist

щас разберусь.

Programmist перевернули для удобства аппаратной обработки, хз чего у их самый левый знаковый и все в инверсе, наверно это связано с аппаратной стыковкой DSP например или какого то кодака МП3 или еще с какой то железякой, данные передаются в i2c.. Зато я разобрался что это действительно так, и пере конвертировал на уровни для отображения, индикатор красиво пляшет теперь, если будет желание сделаю усреднение, посмотрим как ресурсы уйдут. Дело в том что это не программирование а описание схем, все что что пишется потом при компиляции синтезируется в обычную схему которую можно исполнить на логике в пластмассовых корпусах.

Ну, наверно, где-то так, только кучу else лучше убрать, чтобы не гонять зря и сделать Exit, после каждой строки.
Дело в том что это не программирование а описание схем
Ну да, поэтому я здесь советчик плохой, не знаю всех нюансов. Можно только сделать несколько вариантов и проверить, что быстрее работает.

з.ы.
А если скрежет появляется, то это зашкал одного бита амплитуды, не важно, в каком месте, Вот так это выглядит:
http://www.radioscanner.ru/uploader/2012/spectr_2012010407310.jpg
Исходный сигнал был просто крестик. Биты "переворачиваются" и получается не пойми чего...

Exit; а в Verilog как это сделать?

а в Verilog как это сделать?
Ну, если это Паскаль, наверно так и написать - Exit, т.е. нужное значение присвоено, далее выход из процедуры, чтобы не обрабатывать все остальное. Код выше
if Data_L >=32768 else ... else. .. else (Data_L >=2)
дойдет до последней строки и получется всегда Level_L = 16'b0000000000000001;
Хотя нет, можно и так, в Delphi запись немного другая:

procedure TForm1.SpeedButton1Click(Sender: TObject);
var Data_L, Level_L: Longint;
begin
Data_L:= 4096;
if (Data_L >=32768) then Level_L:= 15 else
if (Data_L >=16384) then Level_L:= 14 else
if (Data_L >=8192) then Level_L:= 13 else
if (Data_L >=4096) then Level_L:= 12 else
if (Data_L >=2048) then Level_L:= 11 else
if (Data_L >=1024) then Level_L:= 10 else
if (Data_L >=512) then Level_L:= 9 else
if (Data_L >=256) then Level_L:= 8 else
if (Data_L >=128) then Level_L:= 7 else
if (Data_L >=64) then Level_L:= 6 else
if (Data_L >=32) then Level_L:= 5 else
if (Data_L >=16) then Level_L:= 4 else
if (Data_L >=8) then Level_L:= 3 else
if (Data_L >=4) then Level_L:= 2 else
if (Data_L >=2) then Level_L:= 1;
Caption:= IntToStr(Level_L);
end;

Результат = 12.

Может быть, оператор Case можно использовать, тут не известно, все зависит от компилятора, окончательный результат все равно на asm-e будет, если я правильно понял, для изготовления микросхемы.

не знаю всех нюансов Я сам их еще не знаю, да тут еще в "тайминг" не влажу вероятно.. Иногда не успевают устаканиваться регистры.

пишу так


always @(posedge AUD_DACLRCK)
begin
audio_outL <= audio_inL; // АЦП на ЦАП в разрыв можно обработку
if (TestDevL == 1024) // делитель каждий 1024 отсчет, это так пока чтобы не гонять за зря,
begin
TestDevL=0;
if ((audio_inL >> 15) == 0) //проверяем самый левый бит если ноль значит позитивная часть сигнала
begin
Data_L <= audio_inL;
//таблица конвертации уровней
if (Data_L >=32767) Level_L = 16'b0111111111111111; else
if (Data_L >=16384) Level_L = 16'b0011111111111111; else
if (Data_L >=8192) Level_L = 16'b0001111111111111; else
if (Data_L >=4096) Level_L = 16'b0000111111111111; else
if (Data_L >=2048) Level_L = 16'b0000011111111111; else
if (Data_L >=1024) Level_L = 16'b0000001111111111; else
if (Data_L >=512) Level_L = 16'b0000000111111111; else
if (Data_L >=256) Level_L = 16'b0000000011111111; else
if (Data_L >=128) Level_L = 16'b0000000001111111; else
if (Data_L >=64) Level_L = 16'b0000000000111111; else
if (Data_L >=32) Level_L = 16'b0000000000011111; else
if (Data_L >=16) Level_L = 16'b0000000000001111; else
if (Data_L >=8) Level_L = 16'b0000000000000111; else
if (Data_L >=4) Level_L = 16'b0000000000000011; else
if (Data_L >=2) Level_L = 16'b0000000000000001;
end else // иначе ноль, это негативная часть синусоиды
begin
//Data_L <= audio_inL; // передаем из wire в регистр
// таблица конвертации уровней для индикации
//if (Data_L >=16'b1111111111111110) Level_L = 16'b0000000000000001; else
//if (Data_L >=16'b1111111111111100) Level_L = 16'b0000000000000011; else
//if (Data_L >=16'b1111111111111000) Level_L = 16'b0000000000000111; else
//if (Data_L >=16'b1111111111110000) Level_L = 16'b0000000000001111; else
//if (Data_L >=16'b1111111111100000) Level_L = 16'b0000000000011111; else
//if (Data_L >=16'b1111111111000000) Level_L = 16'b0000000000111111; else
//if (Data_L >=16'b1111111110000000) Level_L = 16'b0000000001111111; else
//if (Data_L >=16'b1111111100000000) Level_L = 16'b0000000011111111; else
//if (Data_L >=16'b1111111000000000) Level_L = 16'b0000000111111111; else
//if (Data_L >=16'b1111110000000000) Level_L = 16'b0000001111111111; else
//if (Data_L >=16'b1111100000000000) Level_L = 16'b0000011111111111; else
//if (Data_L >=16'b1111000000000000) Level_L = 16'b0000111111111111; else
//if (Data_L >=16'b1110000000000000) Level_L = 16'b0001111111111111; else
//if (Data_L >=16'b1100000000000000) Level_L = 16'b0011111111111111; else
//if (Data_L >=16'b1000000000000000) Level_L = 16'b0111111111111111;
end
end else TestDevL = TestDevL+1;
end


работает
закоменитровал наоборот тоже работает, откомменитровал обе нихрена не работает. Опять я вляпался в то что не успевает регистр стабилизироваться.

"тайминг" Это отдельная песня, чем больше дополнительных таймеров, тем менее надежно все работает. Самый лучший вариант - один таймер, если получится в него вписать делители, а в делители - нужные процедуры.
Ну ладно, мешать не буду, надеюсь, что все получится, потому, как деваться ему некуда :)

Вся проблема была понять как данные расположены, собственно я разобрался как дата лежит, а для того чтобы увидеть уровень достаточно и одной половины волны, зачем выпрямлять вторую то? Оставляю индикатор на одну половину. Или можно сделать через такт, допустим каждый 512 тый.

зачем выпрямлять вторую то? Оставляю индикатор на одну половину
Лучше выпрямить и сделать через нужное кол-во тактов, выбрав из них максимальный по амплитуде (проверять все такты), а то с одной половиной может потом непонятка получиться, типа постоянки какой, а на индикаторе - нуль. Если ресурсов не хватает, тогда ничего не остается, как пропускать, но выпрямлять - обязательно.

Programmist так все из за ресурсов, а то разбазарю по пустякам.. Через такты будет частотно зависимое и может попасть на интерференцию. В общем надо продумать, можно в реалтайме задвинуть в регистр с десяток значений и с их вычислить среднее, через делитель на 10 вывести значение, это к примеру конечно, все надо считать.

Вопрос сложный, среднеквадратичные можно вычислять, только обычно в цифре все индикаторы показывают максимальное значение, по крайней мере, во всех известных мне редакторах так. Бывает и возможность выбора, но это уже лишнее, имхо.
В реал тайме в регистр все задвинуть и максимальное выбрать - ресурсов точно должно хватить, главное, чтобы эта процедура ничего не тормозила, при выводе данных, через каждые 512 тактов.

Сделал вот так:

wire [15:0] audio_inL, audio_inR;
reg [15:0] audio_outL,audio_outR;
reg [15:0] Level_R;
reg [15:0] Level_L;
reg [32:0] TestDevL=0;
reg [32:0] TestDevR=0;


always @(posedge AUD_DACLRCK)
begin
audio_outL <= audio_inL; // АЦП на ЦАП в разрыв можно обработку
if (TestDevL == 1024)
begin
TestDevL=0;
if ((audio_inL >> 15) == 0) //проверяем самый левый бит если ноль значит позитивная часть сигнала
begin
//таблица конвертации уровней
if (audio_inL >=32767) Level_L = 16'b0111111111111111; else
if (audio_inL >=16384) Level_L = 16'b0011111111111111; else
if (audio_inL >=8192) Level_L = 16'b0001111111111111; else
if (audio_inL >=4096) Level_L = 16'b0000111111111111; else
if (audio_inL >=2048) Level_L = 16'b0000011111111111; else
if (audio_inL >=1024) Level_L = 16'b0000001111111111; else
if (audio_inL >=512) Level_L = 16'b0000000111111111; else
if (audio_inL >=256) Level_L = 16'b0000000011111111; else
if (audio_inL >=128) Level_L = 16'b0000000001111111; else
if (audio_inL >=64) Level_L = 16'b0000000000111111; else
if (audio_inL >=32) Level_L = 16'b0000000000011111; else
if (audio_inL >=16) Level_L = 16'b0000000000001111; else
if (audio_inL >=8) Level_L = 16'b0000000000000111; else
if (audio_inL >=4) Level_L = 16'b0000000000000011; else
if (audio_inL >=2) Level_L = 16'b0000000000000001;
end
end else TestDevL = TestDevL+1;
end

always @(negedge AUD_DACLRCK)
begin
audio_outR <= audio_inR; // АЦП на ЦАП в разрыв можно обработку
if (TestDevR == 1024)
begin
TestDevR=0;
if ((audio_inR >> 15) == 0) //проверяем самый левый бит если ноль значит позитивная часть сигнала
begin
//таблица конвертации уровней
if (audio_inR >=32767) Level_R = 16'b0111111111111111; else
if (audio_inR >=16384) Level_R = 16'b0011111111111111; else
if (audio_inR >=8192) Level_R = 16'b0001111111111111; else
if (audio_inR >=4096) Level_R = 16'b0000111111111111; else
if (audio_inR >=2048) Level_R = 16'b0000011111111111; else
if (audio_inR >=1024) Level_R = 16'b0000001111111111; else
if (audio_inR >=512) Level_R = 16'b0000000111111111; else
if (audio_inR >=256) Level_R = 16'b0000000011111111; else
if (audio_inR >=128) Level_R = 16'b0000000001111111; else
if (audio_inR >=64) Level_R = 16'b0000000000111111; else
if (audio_inR >=32) Level_R = 16'b0000000000011111; else
if (audio_inR >=16) Level_R = 16'b0000000000001111; else
if (audio_inR >=8) Level_R = 16'b0000000000000111; else
if (audio_inR >=4) Level_R = 16'b0000000000000011; else
if (audio_inR >=2) Level_R = 16'b0000000000000001;
end
end else TestDevR = TestDevR+1;

end

assign LEDR[15:0] = (Level_L & Level_R); //

проверяем самый левый бит если ноль значит позитивная часть сигнала
Оно так и будет, 32767 = 16'b0111111111111111, а 32768 это уже 16'b1000000000000000, дальше - больше.
В общем, проверка первого бита может быть даже и быстрей стандартной процедуры преобразования Bin To Dec, но это только один полупериод.
Вот как-то примерно так: http://files.mail.ru/7FX7M3
Преобразование на Delphi, может сгодится на что.

Programmist думаю сдвинуть на 15 и проверить бит быстрее чем сравнивать два числа 32767. Хз. Или сдвинуть влево на 1 и посмотреть какой бит перенесся это при циклической ротации.

RadioKoteg
Сдвиг напрямую всегда быстрее будет, если его компилятор обратно не завернет. Тут только метод проб и ошибок рулит, пока не будут изучены все тонкости этого компилятора. Иногда можно написать 1000 строк и работает быстро, а иногда и три строчки тормозят.

этого компилятора Синтезатор. Он синтезирует схему.