Talkie-walkie XBee

À propos de ce projet

Je construis un clone Arduino avancé basé sur le MCU AVR ATmega1284p avec quelques fonctionnalités spéciales, notamment un DAC 12 bits MCP4822, un amplificateur pour casque, 2x mémoire SPI (SRAM, EEPROM) et une carte SD. Il existe de nombreuses applications dans le monde réel pour les sorties analogiques, mais comme la plate-forme Arduino n'a pas de capacité DAC intégrée, il existe très peu d'applications publiées pour les signaux analogiques. Un talkie-walkie est un exemple d'utilisation combinée du numérique et de l'analogique pour créer un projet simple mais très utile.

La fonctionnalité réelle du talkie-walkie n'est en réalité que quelques lignes de code, mais elle repose sur une base d'entrée analogique (échantillonnage), une sortie analogique sur le bus SPI vers le DAC MCP4822, des routines de synchronisation d'échantillons et la plate-forme radio numérique XBee. Commençons par le haut, puis creusons à travers les couches.

Radio XBee

J'utilise des radios XBee Pro S2B, configurées pour communiquer point à point. Pour le XBee Pro, une radio doit être configurée en tant que coordinateur et l'autre en tant que routeur. Il existe des guides de configuration sur Internet.

J'ai configuré les radios pour attendre le temps maximum entre les caractères avant d'envoyer un paquet, ce qui implique que les paquets ne seront définis que lorsqu'ils seront pleins (84 octets). Cela maximise le débit radio. Le débit brut est de 250 kbit/s, mais le débit de données utilisateur réel est limité à environ 32 kbit/s. Cela a un impact sur le taux d'échantillonnage et donc sur la qualité de la parole pouvant être transmise.

En utilisant des échantillons de 8 bits, j'ai découvert qu'un échantillonnage d'environ 3 kHz génère à peu près autant de données qu'il est possible de transmettre sans compression. Je quitte la compression pour un autre projet.

Les radios XBee sont configurées en mode AT, qui agit comme un canal série transparent entre les deux points de terminaison. C'est le moyen le plus simple de connecter deux appareils via la radio numérique. Et cela m'a permis de faire des tests simples, en utilisant du fil, avant de me demander si la plate-forme radio fonctionnait ou non.

En regardant le tracé d'un analyseur logique, on peut voir les paquets de données XBee arriver sur la ligne Rx (violette) du port série. Les données de paquet reçues sont stockées dans une mémoire tampon en anneau et lues à un débit constant. J'ai autorisé jusqu'à 255 octets dans la mémoire tampon de l'anneau de réception, et cela sera suffisant car la taille du paquet XBee est de 84 octets.

Les échantillons à transmettre à l'autre appareil sont transmis sur la ligne Tx (bleue), plus ou moins dans chaque période d'échantillonnage même s'ils sont mis en mémoire tampon avant la transmission. La radio XBee met ces octets en mémoire tampon pendant des périodes inter-symboles allant jusqu'à 0xFF (configuration) et ne transmet un paquet à l'autre point de terminaison que lorsqu'il a un paquet complet.

Taux d'échantillonnage

En examinant le bilan binaire de la liaison de transmission, nous devons calculer la quantité de données pouvant être transmises sans surcharger la plate-forme radio XBee et sans entraîner de perte d'échantillon. Comme nous ne compressons pas ouvertement les échantillons de voix, nous avons des échantillons de 8 bits multipliés par 3 000 Hz ou 24 kbit/s à transmettre. Cela semble fonctionner assez bien. J'ai essayé un échantillonnage à 4 kHz, mais celui-ci est trop proche du maximum théorique et ne fonctionne pas trop efficacement.

En regardant l'analyseur logique, on peut voir l'arrivée d'un paquet d'octets commençant par 0x7E et 0x7C sur la ligne Rx. L'amplificateur du microphone et la sortie DAC sont tous deux polarisés autour de 0x7F (FF), nous pouvons donc lire que les niveaux de signal capturés et transmis ici sont très faibles. La fréquence d'échantillonnage indiquée est de 3 000 Hz.

Exemple de traitement

J'ai mis un "ping" sur une sortie pour capturer lorsque l'interruption d'échantillonnage est en cours de traitement (jaune). On voit que le temps passé dans le traitement des interruptions est très faible pour cette application, par rapport au temps total disponible. Peut-être qu'une sorte de compression de données pourrait être mise en œuvre.

Pendant l'interruption d'échantillonnage, il y a deux activités principales, générer une sortie audio, en plaçant un échantillon sur le DAC, puis en lisant l'ADC pour capturer un échantillon audio et le transmettre au tampon USART.

Ceci est fait par la fonction audioCodec_dsp, qui est appelée à partir du code dans une interruption de minuterie.

J'utilise l'AVR 8 bits Timer0 pour générer les intervalles d'échantillonnage réguliers, en déclenchant une interruption. En utilisant une fréquence MCU FCPU qui est un multiple binaire des fréquences audio standard, nous pouvons générer des taux d'échantillonnage de reproduction précis en utilisant uniquement la minuterie 8 bits avec un pré-échelonneur d'horloge de 64. Pour générer des fréquences audio impaires, comme 44 100 Hz, le 16 bit Timer1 peut être utilisé pour obtenir une précision suffisante sans nécessiter de pré-échelonneur d'horloge.

L'ADC ATmega1284p est réglé sur le mode d'exécution libre et est réduit à 192 kHz. Bien qu'elle soit proche de la vitesse d'acquisition maximale documentée pour l'ATmega ADC, elle reste dans les limites des spécifications pour les échantillons 8 bits.

Cette interruption prend 14 us et est très courte par rapport aux 333 us dont nous disposons pour chaque période d'échantillonnage. Cela nous donne beaucoup de temps pour effectuer d'autres traitements, tels que l'exécution d'une interface utilisateur ou un traitement audio supplémentaire.

Transaction SPI

Au dernier niveau de détail, nous pouvons voir la transaction SPI réelle pour sortir l'échantillon entrant vers le DAC MCP4822.

Comme j'ai construit cette application sur le Goldilocks Analogue Prototype 2 qui utilise le bus SPI standard, la transaction est normale. Mes derniers prototypes utilisent le mode Master SPI sur USART 1 de l'ATmega1284p, qui accélère légèrement la transaction SPI grâce à la double mise en mémoire tampon et libère le bus SPI normal pour une lecture ou une écriture simultanée sur la carte SD ou la mémoire SPI, pour le streaming audio. Dans l'application Walkie Talkie, il n'est pas nécessaire de capturer l'audio, il n'y a donc aucun inconvénient à utiliser les anciens prototypes et le bus SPI normal.

Conclusion

À l'aide de quelques outils préexistants et de quelques lignes de code, il est possible de créer rapidement un talkie-walkie crypté numériquement, capable de communiquer une voix (compréhensible, mais pas de haute qualité). Et, il n'y a pas de camionneurs CB qui écouteront les conversations familiales à l'avenir.

Il s'agissait d'un test d'ajout d'une entrée microphone basée sur le MAX9814 à l'analogique Goldilocks. Je vais réviser le prototype 3 et ajouter un circuit d'amplification de microphone pour prendre en charge les applications nécessitant une entrée audio, comme cet exemple de talkie-walkie, ou des changeurs de voix ou des synthétiseurs de musique à commande vocale.

J'utilise également les appareils ATmega1284p à la fréquence accrue de 24,576 MHz, par rapport à la fréquence standard de 20 MHz. Cette fréquence spécifique permet une reproduction très précise des échantillons audio de 48 kHz jusqu'à 4 kHz (voire jusqu'à 1500 Hz). Les cycles d'horloge MCU supplémentaires par période d'échantillonnage sont les bienvenus lorsqu'il s'agit de générer de la musique synthétisée.

Codez comme d'habitude sur Sourceforge AVR freeRTOS Aussi, un appel à Shuyang à SeeedStudio qui est OPL est génial, et est la source de nombreux composants et PCB.

Code

• Code
• Code
• Code

CodeC/C++

void audioCodec_dsp( uint16_t * ch_A, uint16_t * ch_B){ int16_t xn; uint8_t cn; /*----- Audio Rx -----*/ /* Récupère le caractère suivant de la mémoire tampon. */ if( ringBuffer_IsEmpty( (ringBuffer_t*) &(xSerialPort.xRxedChars) ) ) { cn =0x80 ^ 0x55; // met le signal A-Law annulé sur la sortie. } else if (ringBuffer_GetCount( &(xSerialPort.xRxedChars) )> (portSERIAL_BUFFER_RX>>1) ) // si le tampon est plus qu'à moitié plein. { cn =ringBuffer_Pop( (ringBuffer_t*) &(xSerialPort.xRxedChars) ); // pop deux échantillons à rattraper, supprimez le premier. cn =ringBuffer_Pop( (ringBuffer_t*) &(xSerialPort.xRxedChars) ); } else { cn =ringBuffer_Pop( (ringBuffer_t*) &(xSerialPort.xRxedChars) ); // pop un échantillon } alaw_expand1(&cn, &xn); // développe la compression A-Law *ch_A =*ch_B =(uint16_t)(xn + 0x7fff); // déplace le signal vers des valeurs positives, met le signal sur les canaux A et B. /*----- Audio Tx -----*/ AudioCodec_ADC( &mod7_value.u16 ); // l'échantillon est de 10 bits justifié à gauche. xn =mod7_value.u16 - 0x7fe0 ; // centre l'échantillon à 0 en soustrayant 1/2 plage de 10 bits. IIRFilter( &tx_filter, &xn); // filtre le train d'échantillons transmis alaw_compress1(&xn, &cn); // compresse en utilisant A-Law xSerialPutChar( &xSerialPort, cn); // transmettre l'échantillon}

CodeC/C++

ISR(TIMER0_COMPA_vect) __attribute__ ((hot, flatten));ISR(TIMER0_COMPA_vect){#ifdefined(DEBUG_PING) // marque de début - vérifier le début de l'interruption - pour le débogage uniquement (trace jaune) PORTD |=_BV( PORTD7) ; // Ping IO line.#endif // Routine de transfert de données MCP4822 // déplace les données vers le MCP4822 - fait d'abord pour la régularité (gigue réduite). DAC_out (ch_A_ptr, ch_B_ptr); // Routine de traitement audio - effectuez le traitement requis en entrée - préparez la sortie pour le prochain échantillon. // Déclenche le gestionnaire audio global qui est une fonction de rappel, s'il est défini. if (audioHandler!=NULL) audioHandler(ch_A_ptr, ch_B_ptr);#ifdefined(DEBUG_PING) // marque de fin - vérifie la fin de l'interruption - pour le débogage uniquement (trace jaune) PORTD &=~_BV(PORTD7);#endif} 

CodeC/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; écriture.valeur.u8[1] |=CH_A_OUT; } else // ch_A est NULL donc nous désactivons le DAC { write.value.u8[1] =CH_A_OFF; } SPI_PORT_SS_DAC &=~SPI_BIT_SS_DAC; // Tirez sur SS bas pour sélectionner le DAC analogique Goldilocks. SPDR =écriture.valeur.u8[1] ; // Commencer la transmission ch_A. tandis que ( !(SPSR &_BV(SPIF)) ); SPDR =écriture.valeur.u8[0] ; // Continuer la transmission ch_A. if (ch_B !=NULL) // commencer à traiter ch_B pendant que nous effectuons la transmission ch_A { write.value.u16 =(*ch_B)>> 4; écriture.valeur.u8[1] |=CH_B_OUT; } else // ch_B est NULL donc nous désactivons le DAC { write.value.u8[1] =CH_B_OFF; } while ( !(SPSR &_BV(SPIF)) ); // vérifie que nous avons terminé ch_A. SPI_PORT_SS_DAC |=SPI_BIT_SS_DAC ; // Tirez SS haut pour désélectionner le DAC analogique Goldilocks et verrouillez la valeur dans le DAC. SPI_PORT_SS_DAC &=~SPI_BIT_SS_DAC; // Tirez sur SS bas pour sélectionner le DAC analogique Goldilocks. SPDR =écriture.valeur.u8[1] ; // Commencer la transmission ch_B. tandis que ( !(SPSR &_BV(SPIF)) ); SPDR =écriture.valeur.u8[0] ; // Continuer la transmission ch_B. tandis que ( !(SPSR &_BV(SPIF)) ); // vérifie que nous avons terminé ch_B. SPI_PORT_SS_DAC |=SPI_BIT_SS_DAC ; // Tirez SS haut pour désélectionner le DAC analogique Goldilocks et verrouillez la valeur dans le DAC.}

AVRfreeRTOS chez Sourceforge

Schémas