Waves x controle de frequencia

[Vonnilmam]

oi marcelo tudo bem!

me perdõe a minha ignorancia, visto que estou a aprender...

eu agradeço muito sua dica e principalmente a paciencia que esta tendo comigo, muito obrigado.

vamos ver se eu entendi sua sugestão de programa:

como eu ainda sou novato em C (porém viciado em asm), gostaria de uma explicação mais clara da rotina que vc fez, afim de eu poder testa-la no hardware mesmo que eu fiz aquí, aliás tô acabando de montar um num protoboard só para testar o basico, tipo vou gerar um senoide com 256 pontos em 8bits....

me corrija onde eu errar na sua interpretação:

- s0 e s1 são duas variaveis de 8 bits que devem armazenar o resultado da formula table?

- i é outra variavel de 8 bits que serve como um ponteiro afim de indexar a tabela da senoide de 256 pontos?

- i (variavel do ponteiro) * 256 (tamanho máximo da tabela "resolução") * f (frequencia que eu desejo) / 8000 (valor do sample rate) ?

- s0+s1 são variaveis de 8 bits? que contém o resultado da formula table? e também seria o resultado da soma dos canais dada pela formula: variavel 0 + variavel 1 = X / pelo numero de somas que no caso seria 2 e resultado seria enviado para a saida "um dac por exemplo".


Estou fazendo essas perguntas porque vou simular essa formula através de uma rotina que irei montar com base nas suas informações, para isso preciso entender o procedimento.

muito obrigado,

[msamsoniuk]

vou colocar uma versao com comentarios e testada no linux:

Código: Selecionar todos

#include <stdio.h>
#include <math.h>

int main()
{
    FILE *fp; // file descriptor para placa de som no linux
    int i, s0, s1, k1, k2; // variaveis todas int de 32 bits
    char saida, table[256]; // wavetable qq, no exemplo uma senoide

    for(i=0;i!=256;i++) // inicializa wavetable com senoide
    {
      table[i] = (char)(127*sin(i*2.0*M_PI/256.0));
    }

    fp = fopen("/dev/dsp", "w"); // abre a placa de som

    if(fp) // se abrir, roda o codigo, senao vai embora
    {
        k1 = (256*697)/8000;  // k1 de linha  1 697hz
        k2 = (256*1209)/8000; // k2 de coluna 1 1209hz
                              // 1,1 corresponde ao DTMF "1"

        printf("coeficientes: 697Hz => %d, 1209Hz => %d\n",k1,k2);             

        for (i = 0;; i++) // loop eterno
        {
            s0 = table[(unsigned char) (i*k1)]; // primeiro resultado
            s1 = table[(unsigned char) (i*k2)]; // segundo resultado
            saida = (s0 + s1) / 2; // mixer simples
            fputc(saida+128, fp); // envia para a placa de som
                                  // a soma +128 no envio eh necessario
                                  // pq a placa trabalha com pcm nao
                                  // sinalizado, mas para processar audio
                                  // *sempre* use sinalizado
        }
    }
    return -1; // retorna erro se nao conseguir abrir o arquivo
}


para minimizar o problema de overflow, eu calculei o coeficiente antes e multipliquei depois... o problema eh que a menor frequencia vai ser 32Hz (coeficiente 1), enquanto que na maior frequencia (1/4 do sample rate) vc vai ter coeficiente 64, ou seja, na pratica vc soh gera 64 frequencias diferentes na faixa de 32 a 2000Hz.

trocando para:

Código: Selecionar todos

      k1 = (256*697);  // k1 de linha  1 697hz
      k2 = (256*1209); // k2 de coluna 1 1209hz 


e tambem:

Código: Selecionar todos

            s0 = table[(unsigned char)((i*k1)/8000)]; // primeiro resultado
            s1 = table[(unsigned char)((i*k2)/8000)]; // segundo resultado


voce garante capacidade de gerar corretamente de 1 a 2000Hz. porem comeca a ocorrer um overflow periodico, pois os coeficientes variam de 256 a 512000, ou seja, o coeficiente consome 19 bits, sobrando entao apenas 12 bits para o contador i, de modo que ele faz overflow em apenas 4096 contagens (quase 2x por segundo!). mas se vc declarar i como uma variavel long long de 64 bits, o overflow ira demorar alguns anos para ocorrer.

outra alternativa eh usar ponto flutuante:

Código: Selecionar todos

    float k1,k2;
...
        k1 = 256.0*697.0/8000.0;  // k1 de linha  1 697hz
        k2 = 256.0*1209.0/8000.0; // k2 de coluna 1 1209hz
...
            s0 = table[(unsigned char)((int)(i*k1))]; // primeiro resultado
            s1 = table[(unsigned char)((int)(i*k2))]; // segundo resultado


daih fica similar ao primeiro caso lah em cima, soh que agora os coeficientes variam de 0.032 a 64 com grande precisao. usando ponto flutuante de precisao simples, vc consegue sintetizar qq frequencia corretamente e o overflow do inteiro i vai ocorrer apenas depois de 2h de sintese continua da frequencia maxima.

uma forma de resolver o problema de overflow dos indices seria tambem usar um indice separado para cada canal, porem todos incrementando de forma sincronizada de acordo com o sample rate... fica como licao de casa para vc testar isso hehehe

[proex]

Pena que nao roda num PIC.

Minha idéia inicial roda.


.

[fabim]

Pena que nao roda num PIC.

Minha idéia inicial roda.


.

claro que roda!! C num viu que o PIC32 com 115 mips, vai ter FPU ?

oxi, nossa estamos em março!!
achei que era 1° abriu!!

caramba

[msamsoniuk]

sei sei... mostra o codigo ae entao!

Pena que nao roda num PIC.

Minha idéia inicial roda.


.

[barboza]

Se as constantes k1 e k2 são respectivamente 22 e 38 e tabela tem 256 posições o máximo valor de i não deveria ser 6 (256/38)?

Acho que tem algo fora do controle ai.

[proex]

sei sei... mostra o codigo ae entao!

Pena que nao roda num PIC.

Minha idéia inicial roda.


.

Ai Vai:

Código: Selecionar todos

;------------------------------------------------
;  Isso é apenas um exemplo de tabela. Não representa Wave de senoide
TAB_60HZ
      DB   0x3F, 0xFF, 0xFF, 0x80, 0x00, 0x40, 0x00, 0x00
      DB   0x40, 0x00, 0x80, 0x00, 0x00, 0x20, 0x00, 0x80
      DB   0x00, 0x00, 0x20, 0x00, 0x82, 0x3B, 0xB8, 0x20
      DB   0x00, 0x82, 0x22, 0x10, 0x20, 0x00, 0x82, 0x33
      DB   0x10, 0x20, 0x00, 0x82, 0x22, 0x10, 0x20, 0x00
      DB   0x83, 0xBA, 0x10, 0x20, 0x08, 0x80, 0x00, 0x00
      DB   0x20, 0x0C, 0x80, 0x00, 0x00, 0x20, 0xFE, 0xBF
      DB   0xFF, 0xFF, 0xA1, 0x0C, 0xB1, 0xB3, 0x15, 0xA2
      DB   0x08, 0xB6, 0xAF, 0xB5, 0xBC, 0x00, 0xB0, 0xA9
      DB   0xB1, 0xA0, 0x00, 0xB5, 0xAD, 0xB5, 0xA0, 0x00
      DB   0xB6, 0xB3, 0xB5, 0xA0, 0x00, 0xBF, 0xFF, 0xFF
      DB   0xA0, 0x00, 0x9F, 0xFF, 0xFF, 0x20, 0x00, 0x40
      DB   0x00, 0x00, 0x40, 0x00, 0x3F, 0xFF, 0xFF, 0x80
      DB   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0X00, 0X00

;Como ler a tabela acima:

   MOVLW   LOW(TAB_60HZ)
   MOVWF   TBLPTRL
   MOVLW    HIGH(TAB_60HZ)
   MOVWF   TBLPTRH
   TBLRD*+
   MOVFF   TABLAT,DA_LOW
     TBLRD*+
   MOVF   TABLAT,DA_HI
   RETURN   

.

Nao precisa de calculeira e roda rapidinho num PIC. (que é o MCU que ele tá usando)

.

[msamsoniuk]

i eh um inteiro de 32 bits.

Se as constantes k1 e k2 são respectivamente 22 e 38 e tabela tem 256 posições o máximo valor de i não deveria ser 6 (256/38)?

Acho que tem algo fora do controle ai.

[fabim]

oia tava falando com um cara que o putex me apresentou...

o vonnillman, quer um conselho ? Use um blackfin e pronto... é um misto de AD com intel.. da pra você rodar essas tabelas aí a uns 1.2ghz de processamento... acho que vai dar proC fazer o que quer...


Agora TIO. me diz uma coisa.... Só uma pra ver se eu paro de ficar nervoso..

Como ja expliquei anteriormente, sobre instrumentos e tals.

Você vai fazer o que exatamente com isso ?

To tentando imaginar e ainda não consegui...

veja tu esta querendo gerar as frequencias das notas. Só que uma nota de um instrumento, tem frequencias diferentes, e armonicos diferentes.

O LA de um violão, não é o mesmo lá de uma guita, e menos ainda de um cavaquinho..
Porem o LA do violão, é o mesmo de um piano..

Por isso eu to cabreiro, com essa anarquia que tu ta batendo a cuca pra fazer..

Abraços

e não fica dando muita corda pro marcelo sam, nem pro proex não eim.. eles não sabem nem como um pic funciona, pelo menos acho que o putex esqueceu... E o sam tem problemas em trabalhar com partes de nibles de ints.. o cerebro dele só funciona de 24 bits pra cima. tipo 24 32 56 bits...
A perai, verdade, o proex ainda sabe como é pegar nos pica, ele ainda pega um ou outro de vez em quando...

ja o marcelo só os power black, ",,,,,," rs

[msamsoniuk]

mas isso ae nao gera resultado equivalente ao meu codigo... eu falei em um codigo capaz de gerar pelo menos duas senoides mixadas com frequencias arbitrarias entre 1 e 2000Hz. eh obvio que vc soh tem duas situacoes possiveis: ou parte para a calculeira com uma tabela soh ou monta 2000 tabelas.

sei sei... mostra o codigo ae entao!

Pena que nao roda num PIC.

Minha idéia inicial roda.


.

Ai Vai:

Código: Selecionar todos

;------------------------------------------------
;  Isso é apenas um exemplo de tabela. Não representa Wave de senoide
TAB_60HZ
      DB   0x3F, 0xFF, 0xFF, 0x80, 0x00, 0x40, 0x00, 0x00
      DB   0x40, 0x00, 0x80, 0x00, 0x00, 0x20, 0x00, 0x80
      DB   0x00, 0x00, 0x20, 0x00, 0x82, 0x3B, 0xB8, 0x20
      DB   0x00, 0x82, 0x22, 0x10, 0x20, 0x00, 0x82, 0x33
      DB   0x10, 0x20, 0x00, 0x82, 0x22, 0x10, 0x20, 0x00
      DB   0x83, 0xBA, 0x10, 0x20, 0x08, 0x80, 0x00, 0x00
      DB   0x20, 0x0C, 0x80, 0x00, 0x00, 0x20, 0xFE, 0xBF
      DB   0xFF, 0xFF, 0xA1, 0x0C, 0xB1, 0xB3, 0x15, 0xA2
      DB   0x08, 0xB6, 0xAF, 0xB5, 0xBC, 0x00, 0xB0, 0xA9
      DB   0xB1, 0xA0, 0x00, 0xB5, 0xAD, 0xB5, 0xA0, 0x00
      DB   0xB6, 0xB3, 0xB5, 0xA0, 0x00, 0xBF, 0xFF, 0xFF
      DB   0xA0, 0x00, 0x9F, 0xFF, 0xFF, 0x20, 0x00, 0x40
      DB   0x00, 0x00, 0x40, 0x00, 0x3F, 0xFF, 0xFF, 0x80
      DB   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0X00, 0X00

;Como ler a tabela acima:

   MOVLW   LOW(TAB_60HZ)
   MOVWF   TBLPTRL
   MOVLW    HIGH(TAB_60HZ)
   MOVWF   TBLPTRH
   TBLRD*+
   MOVFF   TABLAT,DA_LOW
     TBLRD*+
   MOVF   TABLAT,DA_HI
   RETURN   

.

Nao precisa de calculeira e roda rapidinho num PIC. (que é o MCU que ele tá usando)

.

[vtrx]

Código: Selecionar todos

O LA de um violão, não é o mesmo lá de uma guita, e menos ainda de um cavaquinho..
Porem o LA do violão, é o mesmo de um piano..

Acho que voce kizz dizer que não é o mesmo 'timbre' certo?
Lá é Lá,não muda,pelo menos no meu violão e na minha guitar...

[fabim]

Código: Selecionar todos

O LA de um violão, não é o mesmo lá de uma guita, e menos ainda de um cavaquinho..
Porem o LA do violão, é o mesmo de um piano..

Acho que voce kizz dizer que não é o mesmo 'timbre' certo?

afine o LA de um violão, com um calibrador digital.
Depois afine tabem de uma guitarra.
Monte um circuitinho pra capturar frequencia fundamental.

e faça uma comparação.
O LA do violão tem fundamental 440hz, da guitarra mais alto,do violino mais alto ainda... bom nem sei se no violino tem lá, mais é isso ai , você entendeu..

os afinadores, tem 2 tipos. um que é um frequencimetro, e outro é sabe que o lá, pode ser 440hz ou 440+N, ou 440+n+n...
esse segundo tu paga 500...2000R$, o primeiro tu paga 68R$..

[Iran]

A fundamental de uma nota LA de qq instrumento tem a mesma frequencia desde que estejam na mesma oitava, o que varia e a composiçao harmónica do LA de um instrumento para outro. Isso faz com que instrumentos deferentes tenham tímbres diferentes como disse vrtx.

[vtrx]

afine o LA de um violão, com um calibrador digital.
Depois afine tabem de uma guitarra.

Veja eu quase nunca posto algo que não conheça muito bem,as vezes eu posso comer bola,mas não neste caso.
Eu tenho uma pedaleira digital (que tem o afinador,claro),oque muda é o timbre.
Eu sempre vou ter uma Lá com a quinta corda solta de um violão como vou ter tambem um Lá com a quinta corda solta de uma guitarra,mesmo que eu esteja usando dirtorção,pois é o timbre que é diferente.

A fundamental de uma nota LA de qq instrumento tem a mesma frequencia desde que estejam na mesma oitava

Disse tudo...

[fabim]

nossa, e quem disse que o LA.
de um violão, de uma guitarra ou de um violino estão na mesma oitava ?

O La de um violao equivale o lá da 5° oitava de um piano.. 440hz...
Ja o da guitarra esta ainda mais alto, e do violino ainda mais alto..

Depois a diferença de uma oitava para outra, é coisa de alguns hZ.. e vai até a 5 ou 6° oitava. não me recordo.

A frequencia de ressonancia muda @@@@@ >>>>> MUDA <<<<<<

não confunda um timbre que lembra as associações armonica, com a frequencia fundamental, que éssa é diferente..

é isso que eu to falando, cassilda..

Tempos atras eu fiz um FFT, com frequencia de sample variavel, usando um exemplo na net e o LPC2148.
isso eu estava fazendo para ser um afinador de bancada com uma porrada de recurso, ai fiquei feito louco buscando informação, e acabei desanimando do afinador, pois com um FFT jamais conseguiria diferença de 2,25hz pra saber em qual oitava esta a nota, ou se a nota tocada esta dentro, acima ou abaixo..

Só sei que esse negocio de frequencias das notas são muito complicadas,,

http://caraipora.tripod.com/esc_temp_freq_.htm