Walkie-Talkie Avançado XBee com Arduino, DAC e Amplificadores de Áudio
Componentes e Materiais
| Componente | Quantidade | Observações |
|---|---|---|
| Goldilocks Analogue | 1 | Protótipo; funcionalidade replicável com MCP4822 DAC, Amplificador Microfone, Amplificador Fone, e Arduino Uno |
| MAX9744 | 1 | |
| MAX9814 | 1 | |
| MCP4921 DAC | 1 | |
| Arduino UNO | 1 | |
| Arduino Wireless Shield (Xbee) | 1 |
Sobre o Projeto
Estou construindo um clone avançado de Arduino baseado no MCU AVR ATmega1284p com recursos especiais: DAC 12-bit MCP4822, amplificador de fone, 2x Memória SPI (SRAM, EEPROM), e cartão SD. Existem muitas aplicações reais para saídas analógicas, mas como Arduino não tem DAC integrado, há poucas aplicações publicadas para sinais analógicos. Um Walkie-Talkie é exemplo de uso de digital e analógico junto para projeto simples mas útil.
Rádio XBee
Uso rádios XBee Pro S2B, configurados ponto a ponto. Um como Coordinator, outro como Router. Configurei rádios para esperar tempo máximo entre caracteres antes de enviar pacote (pacotes só quando cheios - 84 bytes), maximizando throughput. Throughput bruto 250 kbit/s, taxa real ~32 kbit/s. Isso afeta taxa de amostragem e qualidade de voz.
Com amostras de 8 bits, ~3 kHz gera dados transmitíveis sem compressão. Deixei compressão para outro projeto.
Rádios em modo AT (pipe serial transparente). Simplifica conexão e permite testes com fio antes de validar rádio.
No analisador lógico, vê-se pacotes XBee chegando na linha Rx (roxa). Dados armazenados em buffer circular e reproduzidos em taxa constante. Buffer de recepção até 255 bytes (pacote XBee = 84 bytes).
Amostras a transmitir saem na linha Tx (azul), bufferizadas antes de transmissão. XBee bufferiza por até 0xFF períodos entre símbolos, transmitindo só quando pacote cheio.
Taxa de Amostragem
Orçamento de bits: 8 bits × 3.000 Hz = 24 kbit/s. Funciona bem. 4 kHz é muito próximo do máximo teórico e não funciona eficazmente.
Processamento de Amostras
Coloquei "ping" numa saída para capturar quando interrupção de amostragem processada (amarelo). Tempo gasto na interrupção é muito pequeno relativo ao tempo total. Possível implementar compressão de dados.
Durante interrupção de amostragem: gerar saída de áudio colocando amostra no DAC, e ler ADC para capturar amostra e transmitir ao buffer USART. Feito pela função audioCodec_dsp, chamada de interrupção de timer.
Uso Timer0 de 8 bits do AVR para intervalos regulares de amostragem via interrupção. Frequência MCU múltipla binária de frequências de áudio padrão permite taxas precisas com prescaler 64. Para frequências ímpares (44.100 Hz), Timer1 de 16 bits dá precisão sem prescaler.
ADC do ATmega1284p em modo free-run, escalado para 192 kHz (próximo ao máximo especificado para amostras 8-bit). Interrupção leva 14 μs, muito curta vs 333 μs por período. Tempo sobra para UI ou processamento adicional.
Transação SPI
No nível final, vê-se transação SPI real para saída de amostra ao MCP4822 DAC. No Goldilocks Analogue Prototype 2 usa barramento SPI padrão. Protótipos posteriores usam Master SPI Mode na USART1 do ATmega1284p, acelerando SPI via double buffering e liberando SPI normal para SD Card ou Memória SPI simultânea. No Walkie-Talkie não há captura de áudio, então não há desvantagem em usar protótipos antigos e SPI normal.
Conclusão
Com ferramentas pré-existentes e poucas linhas de código, é possível construir rapidamente walkie-talkie digitalmente criptografado, capaz de comunicar voz (entendível, mas não alta qualidade). E nada de caminhoneiros CB ouvindo conversas familiares!
Teste de entrada de microfone baseada no MAX9814 no Goldilocks Analogue. Revisarei Prototype 3 adicionando circuito amplificador microfone para aplicações precisando entrada de áudio (walkie-talkie, voice changers, sintetizadores musicais vocais).
Também rodo ATmega1284p a 24.576 MHz (vs 20 MHz padrão). Esta frequência permite reprodução precisa de amostras de áudio de 48 kHz até 4 kHz (ou até 1.500 Hz). Ciclos extras de clock por período são bem-vindos para síntese musical.
Código no Sourceforge AVR freeRTOS. Agradecimento a Shuyang da SeeedStudio.
Código
Função audioCodec_dsp
void audioCodec_dsp(uint16_t * ch_A, uint16_t * ch_B) {
int16_t xn;
uint8_t cn;
/*----- Audio Rx -----*/
if(ringBuffer_IsEmpty((ringBuffer_t*)&(xSerialPort.xRxedChars))) {
cn = 0x80 ^ 0x55; // sinal A-Law nulo na saída
} else if (ringBuffer_GetCount(&(xSerialPort.xRxedChars)) > (portSERIAL_BUFFER_RX>>1)) {
cn = ringBuffer_Pop((ringBuffer_t*)&(xSerialPort.xRxedChars));
cn = ringBuffer_Pop((ringBuffer_t*)&(xSerialPort.xRxedChars)); // descarta primeiro, pega segundo
} else {
cn = ringBuffer_Pop((ringBuffer_t*)&(xSerialPort.xRxedChars));
}
alaw_expand1(&cn, &xn);
*ch_A = *ch_B = (uint16_t)(xn + 0x7fff); // move sinal para valores positivos
/*----- Audio Tx -----*/
AudioCodec_ADC(&mod7_value.u16); // amostra 10 bits left justified
xn = mod7_value.u16 - 0x7fe0; // centraliza amostra
IIRFilter(&tx_filter, &xn); // filtra amostra transmitida
alaw_compress1(&xn, &cn); // comprime A-Law
xSerialPutChar(&xSerialPort, cn); // transmite amostra
}
Interrupção de Timer
ISR(TIMER0_COMPA_vect) __attribute__ ((hot, flatten));
ISR(TIMER0_COMPA_vect) {
#if defined(DEBUG_PING)
PORTD |= _BV(PORTD7); // Ping IO line
#endif
DAC_out(ch_A_ptr, ch_B_ptr);
if (audioHandler!=NULL) audioHandler(ch_A_ptr, ch_B_ptr);
#if defined(DEBUG_PING)
PORTD &= ~_BV(PORTD7);
#endif
}
Saída DAC
void DAC_out(const uint16_t * ch_A, const uint16_t * ch_B) {
DAC_command_t write;
if (ch_A != NULL) {
write.value.u16 = (*ch_A) >> 4;
write.value.u8[1] |= CH_A_OUT;
} else {
write.value.u8[1] = CH_A_OFF;
}
SPI_PORT_SS_DAC &= ~SPI_BIT_SS_DAC;
SPDR = write.value.u8[1];
while (!(SPSR & _BV(SPIF)));
SPDR = write.value.u8[0];
if (ch_B != NULL) {
write.value.u16 = (*ch_B) >> 4;
write.value.u8[1] |= CH_B_OUT;
} else {
write.value.u8[1] = CH_B_OFF;
}
while (!(SPSR & _BV(SPIF)));
SPI_PORT_SS_DAC |= SPI_BIT_SS_DAC;
SPI_PORT_SS_DAC &= ~SPI_BIT_SS_DAC;
SPDR = write.value.u8[1];
while (!(SPSR & _BV(SPIF)));
SPDR = write.value.u8[0];
while (!(SPSR & _BV(SPIF)));
SPI_PORT_SS_DAC |= SPI_BIT_SS_DAC;
}
Esquemáticos
Não é absolutamente correto (usa MCP4725 DAC I2C, não MCP4822 SPI), pois Fritzing não tinha breakout certo da Adafruit. Desenhado em uma direção (exceto Rx/Tx interconectados). Placas XBee substituem os dois fios conectando Rx e Tx. Qualquer rádio com taxa de dados suficiente funciona.
Processo de manufatura
- Principais Considerações para Usinagem Swiss de Alto Volume
- Guia de Prototipagem CNC: Precisão, Velocidade e Produção Custo-Efetiva
- Fabricação Especializada de Eixos: Processos de Precisão e Soluções Personalizadas
- Passivação de Aço Inoxidável: Aumentando a Resistência à Corrosão e Desempenho
- Medindo Sensores Analógicos no Raspberry Pi com um Único Pino GPIO
- Usando ADC MCP3008 para Ler Sensores Analógicos com Raspberry Pi
- Geração de Formas de Onda de Alta Precisão com PCB Customizada Baseada em DAC
- Controlador de Irrigação Inteligente com Windows 10 IoT, Raspberry Pi e Sensores de Umidade XBee
- Por Que Medições Analógicas Impulsionam Performance de Planta
- Cabos Blindados Avançados para Circuitos de Sinal: Técnicas Práticas de Conexão (Parte 2)