Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Manufacturing Technology >> Processo de manufatura

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

  1. Principais Considerações para Usinagem Swiss de Alto Volume
  2. Guia de Prototipagem CNC: Precisão, Velocidade e Produção Custo-Efetiva
  3. Fabricação Especializada de Eixos: Processos de Precisão e Soluções Personalizadas
  4. Passivação de Aço Inoxidável: Aumentando a Resistência à Corrosão e Desempenho
  5. Medindo Sensores Analógicos no Raspberry Pi com um Único Pino GPIO
  6. Usando ADC MCP3008 para Ler Sensores Analógicos com Raspberry Pi
  7. Geração de Formas de Onda de Alta Precisão com PCB Customizada Baseada em DAC
  8. Controlador de Irrigação Inteligente com Windows 10 IoT, Raspberry Pi e Sensores de Umidade XBee
  9. Por Que Medições Analógicas Impulsionam Performance de Planta
  10. Cabos Blindados Avançados para Circuitos de Sinal: Técnicas Práticas de Conexão (Parte 2)