Category Archive: TRX SSB 4 bandes

Mar 06 2015

TRX SSB 4 bandes – Librairie C AVR pour adresser un LCD à HD44780

Le type le plus commun de contrôleur utilisé par les modules LCD est le Hitachi HD44780, qui utilise une interface relativement simple entre le microcontrôleur et l’affichage.
C’est ce type de LCD qui a été choisi pour l’affichage des informations sur le TRX 4 bandes. (Voir le précédent billet pour une démo en vidéo)

Bien qu’il existe plusieurs librairies disponibles pour utiliser ces affichages au moyen d’un microcontrôleur AVR, j’ai opté pour l’option d’écrire ma propre collection de fonctions.
Pour ce faire, toute la documentation nécessaire (et bien plus) est trouvable sur la toile sans aucune difficulté. Il n’y plus qu’à….

Hardware

Avant de passer à la partie programmation, il est nécessaire de préparer et de connecter le microcontrôleur et l’affichage.
Le contrôleur peut être adressé soit avec un bus de 4 bit, soit avec un bus de 8 bit. Je ne sais pas chez vous, mais de mon côté le nombre de ports disponibles sur le uC a tendance à ne jamais être suffisant et c’est pour cette raison que c’est le bus à 4 bit qui a été retenu. Bien entendu il faut compenser ce “manque” de manière logicielle en envoyant chaque byte en deux paquets de quatre bits, les bits de poids fort en premier puis les bit de poids faible.
En plus des quatre bits sus-mentionnés, des lignes de contrôle, au nombre de trois, sont nécessaires :

  • EN ou E : Enable, Entrée de validation
  • RS : Sélection du registre de données ou d’instruction
  • RW : Mode lecture ou écriture

De ces trois, seules deux sont utilisées: EN et RS. La ligne RW permet, en mode lecture, de lire ce qui se trouve dans les différentes mémoire du contrôleur, ce dont je n’ai pas besoin, en tout cas dans un premier temps. Nous la forçons à zéro, c’est à dire en mode écriture.
Voici donc un schéma de principe en exemple :

schema_hd44780

Software

La librarie créée comporte deux fichiers. lcd_hd44780.c qui implémente les fonctions et auquel on ne touche en principe pas. Puis le fichier lcd_hd44780.h qui lui contient les déclarations des fonctions. C’est dans ce fichier que nous allons configurer notre librarie.

Il faut paramétrer la librairie avec les ports qui sont utilisés pour communiquer avec l’affichage :

// Définition des ports -----------------------------------------------------

#define RS_PORT PORTB
#define RS_BIT PB6

#define EN_PORT PORTB
#define EN_BIT PB7

#define DATA_PORT PORTC
#define DATA_BIT PC0 // Position du premier bit des data (lsb).
                     // Les trois autres bits doivent suivre consecutivement.

Les quatre bits de data doivent être sur le même port et se suivre.
Dés maintenant nous pouvons utiliser notre librairie en commençant par l’initialisation du LCD avec la commande init_lcd().

Cette commande initialise l’affichage avec l’affichage visible, le curseur invisible et fixe, puis efface l’écran.
Pour modifier ces états de départ à tout moment, on peut utiliser la fonction lcd_setdisplay(LCD_ON|CURSOR_OFF|CURSOR_NOBLINK); .Les options disponibles sont : CURSOR_ON, CURSOR_OFF, LCD_ON, LCD_OFF, CURSOR_BLINK, CURSOR_NOBLINK.

Ensuite nous pouvons utiliser les commandes d’affichage suivantes autant que nécessaire :

void lcd_putchar(char car); Ecrit un caractère à l’emplacement du curseur
void lcd_putstr(char *text); Ecrit une chaîne à l’emplacement du curseur
void lcd_gotoxy(unsigned char x, unsigned char y); Place le curseur sur l’affichage aux coordonnées X et Y.
void lcd_clrscr(void); Efface l’écran

Et pour terminer, voici un exemple simple :

#include <stdlib.h>
#include <stdio.h>
#include <avr/io.h>
#include <util/delay.h>
#include "lcd_hd44780.h"

int main(void)
{
       DDRB = 0xc0;
       DDRC = 0x0f;

       init_lcd();
       lcd_gotoxy(6,0);
       lcd_putstr("Hello");
       lcd_gotoxy(5,1);
       lcd_putstr("world!);

       while(1)
        {
        }

Vous pouvez télécharger la librairie sur la page download.

73’s

Laurent

 

Permanent link to this article: http://www.hb9fgk.org/trx-ssb-4-bandes-librairie-c-pour-adresser-un-lcd-a-hd44780/

Jan 21 2015

TRX SSB 4 bandes – VFO maison à base de AD9850

Une des pièces maîtresse du transceiver est le VFO. Si l’on veut s’adonner aux plaisirs des modulations numériques, il nous en faut un qui soit relativement stable.
A partir de ce constat, il y a deux solutions. La première est d’acheter un VFO prêt à l’emploi. Il en existe plusieurs, dont les plus connus sont le PA0KLT à base de DDS si-570 et le N3ZI DDS 2 à base d’AD9834.
Ils sont tous deux d’une stabilité très suffisantes, abordables, livrés avec un LCD, faciles à configurer, à utiliser, et donc tout à fait appropriés pour ce projet.

Une autre solution consiste à monter son propre VFO, ce que j’ai choisi pour ce projet. La raisons principale en est que je peux ainsi ajouter les fonctionnalités que je désire à mon VFO. Le microcontrôleur ne servira pas seulement à gérer l’encodeur et le DDS, mais il prendra en charge le LCD sur lequel je pourrai ajouter des informations tel que le VOX, le RIT, les mémoires, les vfo’s, etc..
Je dévoilerai toutes les fonctions prises en charge par le processeur dans un prochain article.

Le DDS s’est imposé très rapidement pour des évidentes raisons de simplicité avec un transceiver multibande. Il y a quelques temps, lors de la construction du kit Ultimate2 de Hans Summer, j’avais remarqué la platine DDS à base d’AD9850 enfichée sur le circuit principal. Après quelques recherches, j’ai trouvé l’identique pour quelques dollars sur Ebay. Ni une ni deux, j’ai passé commande de quelques pièces pour expérimenter sa programmation par un microcontrôleur.

La platine AD9850

ad9850

La platine embarque un oscillateur cadencé à 125MHz et peut générer un signal jusqu’à 40MHz en sinus. Un filtre passe bas 70MHz est présent sur la sortie.
La programmation de la fréquence passe par une interface série. Il suffit de trois signaux plus la masse pour adresser le module :

1.Data : les 40 bits de la fréquence et phase à programmer

2.W_CLK : Signal d’horloge pour la synchro des data

3.FQ_UD : Frequency update, qui valide la fréquence programmée.

 

 

 

La programmation du module

Mes essais ont été effectués avec un microcontrôleur ATtiny45 de chez Atmel. C’est celui ci qui enverra les data au DDS au moyen d’un petit soft en langage C.
Le datasheet du DDS indique comment il faut calculer les 32 bits (ou 4 bytes) de la fréquence à envoyer à l’AD9850 au moyen de la formule suivante :

ad9850_formule_calcul

Les 8 bits suivants sont composés de 2 bits de contrôle, 1 bit « power down » et de 5 bits pour la phase.

Voici un exemple pratique de calcul pour une fréquence de 14.285 MHz.
CLKIN est la fréquence de l’oscillateur du DDS, soit 125MHz.
La formule transformée pour calculer ΔPhase  :

 \bigtriangleup Phase = \frac{f_{out}}{CLKIN}* 2^{32}  \bigtriangleup Phase = \frac{14.285}{125}* 2^{32}Ce qui nous donne comme résultat 49082887 en décimal.
Nous allons convertir cette valeur en binaire : 11101010000010111010000111111
qu’il suffit maintenant de “découper”  en quatre bytes : 00011101  01000001 01110100  00111111
C’est cette série de bits que nous allons envoyer au DDS plus un byte de contrôle que nous pouvons mettre à zéro.
Afin que la manipulation soit plus simple dans notre programme, nous convertissons ces 4 bytes en hexadécimal et nous ajoutons à gauche le byte de contrôle:

0x00 0x1d 0x41 0x74 0x3f

Voici un source en langage C qui permet d’envoyer nos 5 bytes au DDS :

/*
 * AD9850_ex.c
 *
 * Created : 26.10.2014 13:36:25
 * Modified: 27.10.2014 22:15:43
 *
 * Author: HB9FGK - Laurent Ferrari
 *
 * Fonction : Exemple de programmation
 *            du module AD9850.
 *
 * Plateforme : uC ATMEL AVR ATtiny45
 *
 * Description des E/S :
 *               PB0 - out DATA
 *               PB1 - out W_CLK
 *               PB2 - out FQ_UD
 *               PB3 - out RESET AD9850
 */ 
#define F_CPU 8000000UL
#include <avr/io.h>
#include <util/delay.h>

unsigned char usb[5];

void init_start(void){
    usb[0] = 0x3f;    // Les 5 bytes à envoyer, lsb en premier
    usb[1] = 0x74;
    usb[2] = 0x41;
    usb[3] = 0x1d;
    usb[4] = 0x00;    
}

int main(void)
{
    unsigned char i,j;
    init_start();
    _delay_ms(10);
    PORTB |= (1<<PB3);  // Reset du module
    _delay_ms(10);
    PORTB &= ~(1<<PB3);
    _delay_ms(1000);
    PORTB |= (1<<PB1);  // Envoi d'un clock
    _delay_ms(1);
    PORTB &= ~(0x07);
    _delay_us(200);
    PORTB |= (1<<PB2);  // Enable serial mode
    _delay_ms(1);
    PORTB &= ~(0x07);   
    _delay_us(200);
        
  while(1)
  {        
        _delay_ms(1000);
        for (i=0; i<5 ; i++)        
          for (j=0 ; j<8; j++)         // Boucles d'envoi des données et du clock
            {
              PORTB |= ((mode[i]>>j)&1);
              _delay_us(10);
              PORTB |= (1<<PB1);
              _delay_us(10);
              PORTB &= ~(0x07);
              _delay_us(10);
            }
        PORTB |=  (1<<PB2);  // Mise à jour de la fréquence (FQ_UD)
        _delay_ms(1);
        PORTB |=  (1<<PB2);
        _delay_ms(1);
        PORTB &= ~(0x07);
    }
    return 1;
}

Bien entendu il ne s’agit que d’un exemple permettant de programmer une seule fréquence. Pour avoir quelque chose de fonctionnel, le calcul des 5 bytes doit être implémenté dans le microcontrôleur lui même et l’on doit pouvoir agir sur la fréquence par un moyen extérieur.
Sur le VFO développé, j’ai utilisé un encodeur munis d’un switch. Celui ci permet de faire varier la fréquence, et en pressant sur le bouton, de choisir l’incrément.
En plus de 10 mémoires sélectionnables par deux poussoirs, il y a la possibilité de travailler avec deux VFO, soit le A et le B, que l’on choisi au moyen d’un commutateur à bascule.
Le mode est également géré, par une différence de fréquence de 3kHz entre les deux bandes latérales.
Un point important si on ne travaille pas en conversion direct, la fréquence générée par le VFO devra tenir compte de la fréquence intermédiaire.

Comme je l’ai déjà écris plus haut, l’avantage de monter soi même son VFO est que l’on peut lui ajouter toutes les fonctions que l’on désirs. Et si on lui adjoint un écran graphique et tactile, les possibilités sont immenses.
Bien sûr le bémol de cette solution implique de devoir se mettre à écrire du code et par conséquence peut être apprendre le langage C.

Ci-dessous, une petite démonstration du VFO avec quelques fonctions déjà implémentées.

73’s

Laurent

 

Permanent link to this article: http://www.hb9fgk.org/trx-ssb-4-bandes-vfo-maison-a-base-de-ad9850/

0 visitors online now
0 guests, 0 members
Max visitors today: 1 at 12:19 am CET
This month: 4 at 12-07-2019 08:39 pm CET
This year: 18 at 07-23-2019 07:11 pm CEST
All time: 53 at 01-18-2018 01:15 am CET