Plusieurs versions de ce genre de générateur ont déjà été proposés, y compris par le fabricant du processeur (Microchip : AN543, AN655, AN616).
J’ai réalisé un mélange de tout cela, et adapté au PIC16F628, qui pour un prix très raisonnable offre des possibilités très évoluée (3 timers par exemples, et un générateur de PWM).
Ce que je présente aujourd’hui, est extrait d’une réalisation plus complexe, dans laquelle une tonalité d’attente devait aussi être générée.
J’utilise le PWM et le Timer 2 pour générer la tonalité d’attente et la tonalité de fréquence haute en cours de composition. Le Timer 0 sert à générer la tonalité basse, alors que le Timer 1 sert de base de temps, à environ 1 seconde (à 4 pour 1000 prêt), pour d’autres parties du programme, et ½ seconde pour les impulsions de composition du numéro.

La génération de fréquence par un processeur est relativement aisée. Ce qui l’est un peu moins, c’est la transformation du signal carré généré en une sinusoïde suffisamment pure pour être acceptée par les centraux téléphoniques.
D’après Mr Fourier, le développement en série d’un signal carré donne des coefficients nuls pour tous les harmoniques pairs, c’est à dire que les termes en 2f, 4f, etc.. sont nuls. Il ne reste que des coefficients pour les harmonique impairs (3f, 5f, etc..) Voilà qui va nous simplifier la vie.
Les fréquences utilisées par le téléphone sont :

Les combinaisons de fréquences à produire sont les suivantes :

• 1 = 697Hz + 1209Hz
• 2 = 697Hz + 1336Hz
• 3 = 697Hz + 1477Hz
• 4 = 770Hz + 1209Hz
• 5 = 770Hz + 1336Hz
• 6 = 770Hz + 1477Hz
• 7 = 852Hz + 1209Hz
• 8 = 852Hz + 1336Hz
• 9 = 852Hz + 1477Hz
• * = 941Hz + 1209Hz
• 0 = 941Hz + 1336Hz
• # = 941Hz + 1477Hz

• La partie logicielle, qui va nous permettre de générer les fréquences, et
• La partie matériel, qui va mettre en forme les signaux, et les utiliser.

Commençons par la partie programmation.

Le processeur utilisé est un PIC 16F628 de chez Microchip. Pourquoi ce processeur ?
Je pourrais dire pourquoi pas, mais il y a tout de même des raisons :
D’abord c’est un processeur RISC ‘Reduced Instructions Set Core). Avec un jeux de 35 instructions faciles à retenir, on fait tout, et en plus, rapidement. 1 cycle par instruction.
Rien à voir avec les processeurs qui se retrouvent avec 3 ou 4 octets de code rien que pour une instruction.
Les programmes de développement sont gratuitement accessibles, et les outils très peu chers (je ne suis pas payé par Microchip...)
Le brochage de ce processeur est commun à toute une série, ayant d’autres performances, et compatibles avec les anciens, comme le 16F84 bien connu, ce qui permet de faire évoluer son montage, sans reprendre à chaque coup le dessin du circuit. (un sacré avantage..)
Enfin, ces circuits sont d’un prix tout à fait raisonnable et l’approvisionnement en est facile.
Après toute cette pommade, revenons au programme.
Le listing est donné dans le fichier joint zippé, extrait.zip.
Je ne donne que les parties relatives à la fonction décrite ici, le programme complet faisant bien d’autres choses.
La fréquence du quartz est de 11,059Mhz, valeur courante dans les systèmes de communication, et qui nous permet d’obtenir une bonne précision sur les valeurs générées.
D’abord à l’initialisation, il faut paramétrer les trois timers :
Timer0 :
La source du timer0 est fixée sur l’horloge interne, par le bit 5 du registre " OPTION " à 0.
Le bit 5 du registre INTCON à 0, arrête le timer0. Il sera mis en route quand ce sera nécessaire.
Timer1 :
Sur l’horloge interne (Fquartz / 4), et prescaler à 0, interruption autorisée par le bit 0 (TMR1IE) du registre PIE1 (en bank 1).
Timer2 :
Réglé au départ pour générer la tonalité d’attente.
Les deux bits T2CKPS1 et PS0 à 10 donne un prescaler de 16. Le module comparateur CCP1 est utilisé pour faire fonctionner le PWM, en positionnant les bits 2, 3, 4 et 5 du registre CCP1CON.
Le registre PR2 permettra de fixer la fréquence générée.
La notice du 16F628 nous donne la relation :
PWM période = (PR2 + 1) * 4 * Tosc * prescale TMR2, ce qui nous permet de tirer la valeur à mettre dans PR2 pour une fréquence donnée :
PR2 +1 = PWM période / (4 * Tosc * TMR2 prescale) .
Les valeurs à donner à PR2, pour obtenir chacune des 4 fréquences sont les suivantes :
avec Tosc = 1 / 11059 = 90,4ns, soit 4 * Tosc = 361,7ns et prescaler = 16

• Pour 1209Hz, on obtient 0x8F, qui en fait donne 1211 à la mesure
• Pour 1336Hz, on obtient 0x80, qui donne 1335Hz
• Pour 1477Hz, on obtient 0x74, qui donne 1477Hz.

Pour la génération de la tonalité basse, le timer TMR0 n’ayant que 8 bits, on utilise un compteur complémentaire qui va compter le nombre de fois que le TMR0 recycle avec la valeur de preset.
Le fonctionnement est le suivant :
On utilise deux tables, donnant l’une, le nombre de fois que le timer doit tourner, et l’autre, la valeur du chargement de TMR0.
Quand la génération commence, on charge le TMR0 avec la valeur de la table table_tmr0_2, et la sortie est mise à 0. Le Compteur est chargé avec la valeur lue dans la table table_tmr0_1. Chaque instruction, incrémente le TMR0, jusqu’à 0xFF où une interruption est déclenchée.
On décompte alors le compteur, et on recharge TMR0 avec la valeur de la table_tmr0_2, ainsi de suite jusqu’à ce que le compteur soit à 0. A ce moment, la sortie est mise à 1, et le compteur est rechargé à la valeur de la table_tmr0_1, puis le cycle reprend, jusqu’à ce que l’on décide d’arrêter le Timer0.
Ainsi, pour la fréquence de 697Hz, on charge le TMR0 avec 0x39 (57) et on fait tourner 9 fois le timer, avant de générer un changement de sortie.
Le nombre d’instruction entre l’entrée de la fonction d’interruption et l’instruction de rechargement du TMR0 a une influence sur la fréquence de sortie.
C’est pour cette raison que le traitement de l’interruption du TMR0 est traitée immédiatement après les préliminaires, laissant toute liberté pour travailler sur le reste du programme, sans interférer avec le réglage de fréquence.

Pour éviter de retourner interroger les tables à chaque passage, les valeurs pour la fréquence en cours de génération sont stockées dans deux registres temporaires mem_Cpt1 pour la table 1, et mem_tmr0 pour la table 2.

Donc, pour générer un double tonalité, il faut récupérer les paramètres relatifs à chaque générateur. Pour cela, on utilise 3 tables. Les deux premières ont déjà été mentionnées ci-dessus, et la troisième, table_pwm, donne la valeur à charger dans le registre PR2 du Timer2.
Ensuite, on charge les registres avec les valeurs lues et mémorisées dans des registres temporaires.
Puis, lorsque tout est en place, on libère les deux timers, par leur flags TMR2ON et T0IE.
La composition d’un numéro de téléphone suppose que l’on a stocké quelque part dans un buffer, la suite des chiffres à envoyer.
Cela est fait par une autre partie du programme, non décrite ici, et qui gère aussi la saisie au clavier..
Le numéro est stocké dans le buffer appelé InBuf, et sa longueur est dans un registre ‘L_num'.
La fonction " composition " du programme proposé s’occupe de récupérer les chiffres les uns après les autres, et de lancer la génération des tonalités.
Chaque tonalité doit durer un temps quelconque, supérieur à 100ms pour être pris en compte.
J’ai choisi 0,5 seconde, parce que c’est facile à compter, à partir du compteur de secondes installé par le timer1.
Avec la fréquence quartz choisie, le Timer1 doit recycler 38 fois pour cadencer la seconde.
Si au passage à 19, on bascule un flag, on obtient notre fenêtre d’une demi seconde.
La génération des tonalités ne commence que quand ce flag monte à 1, et s’arrête quand il redescend.
Chaque chiffre est représenté par une combinaison de fréquences. Ces combinaisons sont données par une quatrième table table_ton, dont chaque sortie fournie 2 valeurs dans l’octet de sortie. Par les quatre bits de poids fort, on défini l’entrée des tables tmr0_1 et 2, et par les quatre bits de poids faible, on défini l’entrée de la table table_pwm.
Je pense que les commentaires du listing devraient suffire à expliquer le reste..