Sons polifônicos de um microcontrolador?

Posso emitir sons monofônicos alternando um único pino ( a uma taxa variável ) conectado a uma campainha piezo.

Como posso gerar dois sinais de áudio mistos no software para criar polifonia?

Aqui está o código que estou usando para tocar uma música simples.

#define F_CPU 8000000UL // 8MHz
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/delay.h>

// number of timer0 overflows/sec
#define INT_PER_SEC 31250

// Frequencies (in Hz) of notes
#define F_FSH_4 370
#define F_A_4 440
#define F_B_4 494
#define F_E_4 330
#define F_CSH_5 554
#define F_D_5 587
#define F_FSH_5 740
#define F_CSH_4 277
#define F_GSH_4 415

// number of timer0 overflows for notes
#define REST -1 // special case
#define FSH_4 INT_PER_SEC/F_FSH_4
#define A_4 INT_PER_SEC/F_A_4
#define B_4 INT_PER_SEC/F_B_4
#define E_4 INT_PER_SEC/F_E_4
#define CSH_5 INT_PER_SEC/F_CSH_5
#define D_5 INT_PER_SEC/F_D_5
#define FSH_5 INT_PER_SEC/F_FSH_5
#define CSH_4 INT_PER_SEC/F_CSH_4
#define GSH_4 INT_PER_SEC/F_GSH_4

#define SEMIQUAVER_TIME 60  // ms
#define BREATH_TIME 20      // ms

volatile uint32_t intrs = 0;
volatile int32_t curNote = REST;

// TIMER0 overflow
ISR(TIMER0_OVF_vect)
{
    if (curNote == REST)
        intrs = 0;
    else
    {
        intrs++;
        if (intrs >= curNote)
        {
            PORTD ^= _BV(PD4);
            intrs = 0;
        }
    }
}


void play(int32_t note, uint32_t len)
{
    int i;
    curNote = note;
    for (i = 0; i< len; i++)
        _delay_ms(SEMIQUAVER_TIME);
    curNote = REST;
    _delay_ms(BREATH_TIME);
}

int main(void)
{
    /* setup clock divider. Timer0 overflows on counting to 256.
     * 8Mhz / 1 (CS0=1) = 8000000 increments/sec. Overflows every 256, so 31250
     * overflow interrupts/sec */
    TCCR0B |= _BV(CS00);

    // enable overflow interrupts
    TIMSK0 |= _BV(TOIE0);

    // PD4 as output
    DDRD = _BV(PD4);

    TCNT0 = 0;
    intrs = 0;

    curNote = REST;

    // enable interrupts
    sei();

    while (1)
    {
        // Axel F
        play(FSH_4, 2);
        play(REST, 2);
        play(A_4, 3);
        play(FSH_4, 2);
        play(FSH_4, 1);
        play(B_4, 2);
        play(FSH_4, 2);
        play(E_4, 2);
        play(FSH_4, 2);
        play(REST, 2);
        play(CSH_5, 3);
        play(FSH_4, 2);
        play(FSH_4, 1);
        play(D_5, 2);
        play(CSH_5, 2);
        play(A_4, 2);
        play(FSH_4, 2);
        play(CSH_5, 2);
        play(FSH_5, 2);
        play(FSH_4, 1);
        play(E_4, 2);
        play(E_4, 1);
        play(CSH_4, 2);
        play(GSH_4, 2);
        play(FSH_4, 6);
        play(REST, 12);
    }
}

Bem, um truque fácil é usar dois pinos com PWM e amarrá-los aos lados opostos do alto-falante. Em seguida, module cada pino em uma velocidade diferente e você poderá tocar duas notas ao mesmo tempo ... basicamente o alto-falante as está misturando para você. Mais de duas notas e você terá que fazer isso no software, conforme mencionado.

A maneira padrão de obter polifonia é interromper a uma taxa de interrupção fixa (geralmente 8000 Hz ou 44100 Hz), obter um "alto" (+1) ou "baixo" (-1) (ou algo intermediário) de cada fonte de som , some todos os números para obter um total e envie esse número total para o DAC.

Como outros já disseram aqui, com um pouco de inteligência, um PWM de alta velocidade pode substituir um DAC.

A página "polifonia do microcontrolador" fornece mais detalhes e dicas.

Eu acho que essa bela e pequena joia do jogo PC DOS usou som polifônico real através do alto-falante do PC: Digger .

Não sei como eles fizeram isso, mas você pode fazer o download do código-fonte C no site.

Isso pode ajudar -> DW PWM simples

você pode simplesmente adicionar duas ondas quadradas e usar pwm rápido para emitir o sinal "analógico" para o alto-falante.

aqui está outro método diferente, se você gosta do som do jogo, rápido e sujo:

https://gitweb.bl0rg.net/cgi-bin/gitweb.cgi?p=arduinisten.git;a=blob;f=projekte/soundz/arpeggio/arpeggio.pde;h=6ceb64a57916c094e87e5983c07b5dd1b4623083;

Se você estiver usando o software para cronometrar os eventos do alto-falante, a abordagem mais fácil é provavelmente gerar dois fluxos de dados independentes e alternar entre eles. Essa abordagem pode funcionar muito bem se a saída do alto-falante é controlada por um pino de E / S ou um DAC. Por exemplo:

int seletor;
fase uint16_t [8], frequência [8];


interrupção nula (nula)
{
  seletor ++;
  seletor & = 7;
  fase [seletor] + freq [seletor];
  DAC_OUT = onda senoidal [fase [seletor] >> 8];
}

A descrição acima é a abordagem essencial que usei em uma caixa de música baseada em PIC em 1996 (usando código de montagem em vez de C). Observe que a taxa de interrupção deve ser 8 vezes a taxa de amostragem efetiva, mas cada interrupção precisa fazer o processamento apenas para uma única voz. Observe que, se a filtragem de saída for boa, essa abordagem produzirá 3 bits a mais de resolução DAC efetiva do que a adição de amostras numericamente e a saída delas, mas gerará muito ruído na taxa de amostragem e múltiplos dela. A filtragem é, portanto, ainda mais importante do que seria.

Eles costumavam fazer isso em sistemas de jogos antigos e nos dias de " alto-falantes do PC ", mas eu não sei como.

Primeiro palpite: pense na onda que você idealmente faria, imagine-a distorcendo-a em uma forma quadrada fortemente cortada e, em seguida, crie essa forma quadrada alternando sua saída nos momentos apropriados. Teria muita intermodulação , no entanto.

Segundo pensamento: você pode aumentar significativamente a frequência dos sinais analógicos de oscilação e saída no estilo PWM ?

Como já foi mencionado, você pode fazer isso da mesma maneira que costumava ser feito com um alto-falante de PC (que suporta apenas on / off opcionalmente conectado a um controlador PWM.) Basicamente, meu entendimento do método é que você liga e desliga o alto-falante rápido o suficiente para nunca estar totalmente ligado ou desligado (um pouco como o funcionamento de uma fonte de alimentação comutada). Isso deixa o alto-falante constantemente se movendo entre ligado e desligado, gerando um sinal analógico.

As únicas dicas são que você precisa de um alto-falante real (acho que um piezo se move tão rápido que chega cheio e muito rápido) e você precisa ser capaz de alternar o pouco rápido o suficiente. Fiz alguns experimentos e obtive uma velocidade máxima de cerca de 5 MHz, que deveria ser suficiente para um sinal de áudio de 11.025 Hz (provavelmente a melhor qualidade que você poderia obter).

É claro que 11025Hz a 8 bits é de 11 kilobytes / segundo, o que é muito mais rápido que a velocidade de uma porta serial. Isso permitiria que apenas um ou dois segundos de áudio fossem armazenados no flash, então você está praticamente limitado a reproduzir áudio gerado em tempo real, desde que haja tempo de CPU suficiente para mexer no alto-falante!

Existem alguns outros métodos para conseguir isso também, e parece que já existe uma implementação para o Arduino do método descrito acima.

Você pode adicionar os fluxos como descrito aqui:

http://www.vttoth.com/digimix.htm

Reproduza o som A por um momento, como talvez 50 ms, depois toque o B e alterne. A idéia é mudar mais rápido do que o ouvido pode dizer e soará como os dois tocando ao mesmo tempo.

Acredito que exista uma biblioteca de tons para o Arduino que faça dois tons. Você poderá adaptar o código ao chip AVR que está usando. Também existem alguns excelentes threads de geração de formas de onda no arduino.cc

Se você decidir adicionar um DAC, tenho um exemplo de oscilador controlado numericamente em http://wiblocks.luciani.org/docs/app-notes/nb1a-nco.html Quatro canais de saída independentes. O quad DAC e a referência custam apenas cerca de US $ 2.

Aqui está o meu código para reproduzir 2 músicas ao mesmo tempo. Desculpe, você precisa se registrar no AVR Freaks para obter acesso.