XBee Walkie Talkie

Componentes e suprimentos

Goldilocks Analogue

Ainda como protótipo atualmente, mas a funcionalidade pode ser recriada com MCP4822 DAC, amplificador de microfone e amplificador de fone de ouvido, junto com o Arduino Uno.

MAX9744

MAX9814

MCP4921 DAC

Arduino UNO

Arduino Wireless Shield (Xbee)

Sobre este projeto

Estou construindo um clone avançado do Arduino baseado no AVR ATmega1284p MCU com alguns recursos especiais, incluindo um DAC MCP4822 de 12 bits, amplificador de fone de ouvido, 2x SPI Memory (SRAM, EEPROM) e um cartão SD. Existem muitos aplicativos do mundo real para saídas analógicas, mas como a plataforma Arduino não tem capacidade DAC integrada, há muito poucos aplicativos publicados para sinais analógicos. Um Walkie Talkie é um exemplo de uso digital e analógico juntos para fazer um projeto simples, mas muito útil.
Goldilocks Analogue - Prototype 3

A funcionalidade real do Walkie Talkie consiste em apenas algumas linhas de código, mas é construída sobre uma base de entrada analógica (amostragem), saída analógica no barramento SPI para o DAC MCP4822, rotinas de temporização de amostragem e a plataforma de rádio digital XBee. Vamos começar do topo e, em seguida, explorar as camadas.

Rádio XBee

Estou usando rádios XBee Pro S2B, configurados para se comunicar ponto a ponto. Para o XBee Pro, é necessário haver um rádio configurado como Coordenador e o outro como Roteador. Existem guias de configuração na Internet.

Configurei os rádios para aguardar o tempo máximo entre caracteres antes de enviar um pacote, o que implica que os pacotes serão configurados somente quando estiverem cheios (84 bytes). Isso maximiza a taxa de transferência do rádio. A taxa de transferência bruta é de 250 kbit / s, mas a taxa real de dados do usuário é limitada a cerca de 32 kbit / s. Isso tem um impacto na taxa de amostragem e, portanto, na qualidade da fala que pode ser transmitida.

Usando amostras de 8 bits, descobri que a amostragem de cerca de 3 kHz gera a mesma quantidade de dados que pode ser transmitida sem compressão. Estou deixando a compressão para outro projeto.

Os rádios XBee são configurados no modo AT, que atua como um tubo serial transparente entre os dois terminais. Esta é a maneira mais simples de conectar dois dispositivos via rádio digital. E me permitiu fazer testes simples, usando fio, antes de me preocupar se a plataforma de rádio estava funcionando ou não.

Olhando para o rastreamento de um analisador lógico, podemos ver os pacotes de dados XBee chegando na linha Rx (roxa) da porta serial. Os dados do pacote recebido são armazenados em um buffer de anel e reproduzidos a uma taxa constante. Eu permiti até 255 bytes no buffer de anel de recebimento e isso será suficiente porque o tamanho do pacote XBee é de 84 bytes.

As amostras a serem transmitidas para o outro dispositivo são transmitidas na linha Tx (azul), mais ou menos em cada período de amostra, embora sejam armazenadas em buffer antes da transmissão. O rádio XBee armazena esses bytes em buffer por até 0xFF períodos entre símbolos (configuração) e apenas transmite um pacote para o outro ponto de extremidade quando ele tem um pacote completo.

Taxa de amostragem

Olhando para o orçamento de bits para o link de transmissão, precisamos calcular quantos dados podem ser transmitidos sem sobrecarregar a plataforma de rádio XBee e causar perda de amostra. Como não estamos comprimindo abertamente as amostras de voz, temos amostras de 8 bits vezes amostragem de 3.000 Hz ou 24 kbit / s para transmitir. Isso parece funcionar muito bem. Eu tentei a amostragem de 4 kHz, mas isso está muito perto do máximo teórico e não funciona com muita eficácia.

Olhando para o analisador lógico, podemos ver a chegada de um pacote de bytes começando com 0x7E e 0x7C na linha Rx. Tanto o amplificador de microfone quanto a saída DAC são polarizados em torno de 0x7F (FF), então podemos ler que os níveis de sinal capturados e transmitidos aqui são muito baixos. A taxa de amostragem mostrada é de 3.000 Hz.

Processamento de amostra

Coloquei um “ping” em uma saída para capturar quando a interrupção de amostragem está sendo processada (amarelo). Podemos ver que o tempo gasto no processamento da interrupção é muito pequeno para esta aplicação, em relação ao tempo total disponível. Possivelmente, algum tipo de compactação de dados poderia ser implementado.

Durante a interrupção da amostragem, existem duas atividades principais, gerar uma saída de áudio, colocando uma amostra no DAC e, em seguida, lendo o ADC para capturar uma amostra de áudio e transmiti-la ao buffer USART.

Isso é feito pela função audioCodec_dsp, que é chamada a partir do código em uma interrupção do temporizador.

Estou usando o AVR 8 bit Timer0 para gerar os intervalos regulares de amostra, disparando uma interrupção. Ao usar uma frequência MCU FCPU que é um múltiplo binário das frequências de áudio padrão, podemos gerar taxas de amostragem de reprodução precisas usando apenas o temporizador de 8 bits com um prescaler de relógio de 64. Para gerar frequências de áudio estranhas, como 44.100 Hz, o 16 O bit Timer1 pode ser usado para obter precisão suficiente sem a necessidade de um pré-calibrador de relógio.

O ATmega1284p ADC está definido para o modo de execução livre e é reduzido para 192 kHz. Embora esteja perto da velocidade de aquisição máxima documentada para o ATmega ADC, ainda está dentro da especificação para amostras de 8 bits.

Essa interrupção leva 14 nós para ser concluída e é muito curta em relação aos 333 nós que temos para cada período de amostra. Isso nos dá muito tempo para fazer outro processamento, como executar uma interface de usuário ou processamento de áudio posterior.

Transação SPI

No nível final de detalhe, podemos ver a transação SPI real para enviar a amostra de entrada para o DAC MCP4822.

Como eu construí este aplicativo no Goldilocks Analogue Prototype 2 que usa o barramento SPI padrão, a transação é normal. Meus protótipos posteriores estão usando o modo Master SPI no USART 1 do ATmega1284p, que acelera ligeiramente a transação SPI por meio de buffer duplo e libera o barramento SPI normal para leitura ou gravação simultânea no cartão SD ou memória SPI, para streaming de áudio. No aplicativo Walkie Talkie, não há necessidade de capturar o áudio, então não há lado negativo em usar os protótipos mais antigos e o barramento SPI normal.

Conclusão

Usando algumas ferramentas pré-existentes e algumas linhas de código, é possível construir rapidamente um walkie talkie criptografado digitalmente, capaz de comunicar (compreensível, mas não de alta qualidade) voz. E, não há nenhum caminhoneiro CB que vai ouvir as conversas da família daqui para frente.

Este foi um teste de adição de entrada de microfone baseada no MAX9814 ao Goldilocks Analogue. Estarei revisando o Protótipo 3 e adicionarei um circuito de amplificação de microfone para suportar aplicativos que precisam de entrada de áudio, como este exemplo de walkie-talkie, ou trocadores de voz, ou sintetizadores de música de controle vocal.
Dois protótipos analógicos Goldilocks com rádios XBee e amplificadores de microfone.

Também estou executando os dispositivos ATmega1284p na frequência aumentada de 24,576 MHz, acima da taxa padrão de 20 MHz. Esta frequência específica permite a reprodução muito precisa de amostras de áudio de 48 kHz até 4 kHz (ou até 1.500 Hz). Os ciclos de clock MCU extras por período de amostra são muito bem-vindos quando se trata de gerar música sintetizada.

Codifique como de costume no Sourceforge AVR freeRTOS Além disso, uma chamada para Shuyang no SeeedStudio que é OPL é incrível e é a fonte de muitos componentes e PCBs.

Código

Código
Código
Código

Código C / C ++

 void audioCodec_dsp (uint16_t * ch_A, uint16_t * ch_B) {int16_t xn; uint8_t cn; / * ----- Audio Rx ----- * / / * Pega o próximo caractere do buffer de anel. * / if (ringBuffer_IsEmpty ((ringBuffer_t *) &(xSerialPort.xRxedChars))) {cn =0x80 ^ 0x55; // coloca o sinal anulado A-Law na saída. } else if (ringBuffer_GetCount (&(xSerialPort.xRxedChars))> (portSERIAL_BUFFER_RX>> 1)) // se o buffer estiver mais da metade cheio. {cn =ringBuffer_Pop ((ringBuffer_t *) &(xSerialPort.xRxedChars)); // pop duas amostras para recuperar, descarte a primeira. cn =ringBuffer_Pop ((ringBuffer_t *) &(xSerialPort.xRxedChars)); } else {cn =ringBuffer_Pop ((ringBuffer_t *) &(xSerialPort.xRxedChars)); // pop uma amostra} alaw_expand1 (&cn, &xn); // expanda a compressão A-Law * ch_A =* ch_B =(uint16_t) (xn + 0x7fff); // move o sinal para valores positivos, coloca o sinal no canal A e B. / * ----- Audio Tx ----- * / AudioCodec_ADC (&mod7_value.u16); // a amostra é 10 bits justificada à esquerda. xn =mod7_value.u16 - 0x7fe0; // centraliza a amostra em 0 subtraindo 1/2 do intervalo de 10 bits. IIRFilter (&tx_filter, &xn); // filtra o trem de amostra transmitido alaw_compress1 (&xn, &cn); // comprimir usando A-Law xSerialPutChar (&xSerialPort, cn); // transmita a amostra}

Código C / C ++

 ISR (TIMER0_COMPA_vect) __attribute__ ((quente, achatar)); ISR (TIMER0_COMPA_vect) {# se definido (DEBUG_PING) // marca de início - verificar o início da interrupção - para depuração apenas (traço amarelo) PORTD | =_BV ( PORTD7); // Ping IO line. # Endif // Rotina de transferência de dados MCP4822 // move dados para o MCP4822 - feito primeiro para regularidade (jitter reduzido). DAC_out (ch_A_ptr, ch_B_ptr); // rotina de processamento de áudio - faça qualquer processamento na entrada necessário - prepare a saída para a próxima amostra. // Aciona o manipulador de áudio global que é uma função de retorno de chamada, se definido. if (audioHandler! =NULL) audioHandler (ch_A_ptr, ch_B_ptr); # if defined (DEBUG_PING) // marca final - verificar o fim da interrupção - para depuração apenas (traço amarelo) PORTD &=~ _BV (PORTD7); # endif}

Código C / C ++

 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 // ch_A é NULL, então desligamos o DAC {write.value.u8 [1] =CH_A_OFF; } SPI_PORT_SS_DAC &=~ SPI_BIT_SS_DAC; // Puxe SS para baixo para selecionar o DAC analógico Goldilocks. SPDR =write.value.u8 [1]; // Comece a transmissão ch_A. enquanto (! (SPSR &_BV (SPIF))); SPDR =write.value.u8 [0]; // Continue a transmissão ch_A. if (ch_B! =NULL) // inicia o processamento de ch_B enquanto estamos fazendo a transmissão de ch_A {write.value.u16 =(* ch_B)>> 4; write.value.u8 [1] | =CH_B_OUT; } else // ch_B é NULL, então desligamos o DAC {write.value.u8 [1] =CH_B_OFF; } enquanto (! (SPSR &_BV (SPIF))); // verifique se terminamos ch_A. SPI_PORT_SS_DAC | =SPI_BIT_SS_DAC; // Puxe SS para cima para desmarcar o DAC analógico Goldilocks e travar o valor no DAC. SPI_PORT_SS_DAC &=~ SPI_BIT_SS_DAC; // Puxe SS para baixo para selecionar o DAC analógico Goldilocks. SPDR =write.value.u8 [1]; // Comece a transmissão ch_B. enquanto (! (SPSR &_BV (SPIF))); SPDR =write.value.u8 [0]; // Continue a transmissão ch_B. enquanto (! (SPSR &_BV (SPIF))); // verifique se terminamos ch_B. SPI_PORT_SS_DAC | =SPI_BIT_SS_DAC; // Puxe SS para cima para desmarcar o DAC analógico Goldilocks e travar o valor no DAC.}

AVRfreeRTOS na Sourceforge

Repositório da porta AVR de freeRTOS, incluindo os arquivos de teste DAC.h e analógico usados neste projeto. NÃO use o repositório github vinculado. Vá para o sourceforge para obter o código mais recente .https://sourceforge.net/projects/avrfreertos /https://github.com/feilipu/avrfreertos

Esquemas

Não é absolutamente correto, visto que está usando um MCP4725 DAC (I2C) e não um MCP4822 DAC (SPI), mas Fritzing não tinha a placa de breakout Adafruit certa.

Além disso, ele é desenhado em apenas uma direção ... (com exceção de Rx e Tx serem interconectados).
As placas XBee simplesmente substituem os dois fios que conectam o Rx e o Tx. Qualquer rádio que possa transportar dados suficientes funcionaria.

Esquemas para a saída DAC e o amplificador de fone de ouvido.
O amplificador de entrada do microfone será adicionado ao protótipo 4.

Determinando a saúde das plantas com TinyML Resposta de temperatura por SMS

Processo de manufatura

impressao 3D

Sistema de controle de automação

Tecnologia industrial