Catégorie : BitX

Code source VFO avec DDS AD9850/AD9851 et LaunchPad MSP430

sVFO DDS AD9850 MSP430 XV4Y (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2013/03/100_3446 NULL.jpg)J’ai eu le temps de mettre la main à une première version d’un programme simple de VFO pour mon kit à base de DDS AD9850 ou AD9851 (http://xv4y NULL.radioclub NULL.asia/boutique/?slug=product_info NULL.php&products_id=33).

Cette première mouture reste assez simple avec juste un système VFO A et VFO B mais pas de mémoires. Les fonctionnalités des boutons suivent la description ci-dessous.

 

Pour une pression brève sur le bouton :

  • UP : Augmente la valeur du chiffre sélectionné (pour le VFO sélectionné)
  • DOWN : Diminue la valeur du chiffre sélectionné (pour le VFO sélectionné)
  • LEFT : Sélectionne le chiffre de rang supérieur (plus à gauche)
  • RIGHT : Sélectionne le chiffre de rang inférieur (plus à droite)
  • OK : Valide la fréquence et la transmet au DDS

Pour une pression longue (supérieure à 1 seconde) sur le bouton :

  • LEFT : Positionne la fréquence sur la limite basse de la bande suivante
  • RIGHT : Egalise les fréquences des deux VFO (VFO A = VFO B)
  • OK : Change le VFO sélectionné (VFO A/B)

A noté que la broche P2_2 du MSP430 (celle connectée à la broche 3 du connecteur 4 pins) est maintenant utilisée en entrée. Si son état change (passant à 0V par exemple), le VFO actuellement utilisé est momentanément interverti. Cela permet donc de trafiquer en split avec la fréquence transmise par le DDS qui change du VFO A vers VFO B (ou l’inverse) tant que la PTT est pressée.

/* Simple VFO with DDS for MSP430G2553
 * Code for Energia 009

 * By Yannick DEVOS - XV4Y - March 2013
    http://xv4y.radioclub.asia/

    Copyright 2012-2013 Yannick DEVOS under GPL 3.0 license
    Any commercial use or inclusion in a kit is subject to author approval

====
 * Agile Frequency generation using AD9850/9851 DDS
 * Output to Nokia 5110 compatible LCD
 * Check if P2_2 has changed state and switch VFO (like when PTT is pressed to operate split)

Usage for short press of buttons :
- Up / Down      increase or decrease the frequency following the choosen digit
- Left / Right   increase or decrease the digit
- OK             validate the frequency and send it to the DDS
Long press of buttons :
- Left           Set the current VFO to the next band bottom frequency
- Right          VFO A = VFO B
- OK             Switch between VFO A and VFO B

====
Revision history :
v1.00    2013-03-18
         First release

====
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You can download a copy of the GNU General Public License at <http://www.gnu.org/licenses/>
*/

// Here modify to your taste or needs

#define PTT_key          P2_2
#define ANALOG_BUTTONS   A5
//#define AUTO_VALID       // Uncomment if you want the DDS frequency to be udapted automatically after each value change

#define DEFAULT_FREQ    8            // Value 8 in Frequencies array is 14000000
// Here under don't touch anything unless you know what you do

#include <legacymsp430.h>
#include <AD9850.h> // Library for AD9850 control by MSP430

#include <LCD_5110.h>

              // Frequencies (1 Hz precision) you can select
const unsigned long int frequencies[] = {
  137000, 471000, 501000, 1830000, 3500000, 5200000, 7000000, 10100000,
  14000000, 18068000, 21000000, 24890000, 28000000, 50000000, 70000000};

const byte Analog_Noise = 5;    // Margins for reading analog buttons

boolean   vfo=0, saved_PTT;  // VFO A or B and PTT input state
char      multiplier, aff_multiplier, freq_select=DEFAULT_FREQ;
unsigned  long int frequency_A=frequencies[DEFAULT_FREQ], frequency_B=frequencies[DEFAULT_FREQ], debounce;

char chaine_txt[6] = {' ', ' ', ' ', ' ', ' ', 0x00};

//AD9850 myDDS (P1_0, P1_1, P1_2, P1_4);  // Call the AD9850 Library, AD9850 pins for CLOCK, LOAD, DATA and RESET
AD9850 myDDS (P1_1, P1_2, P1_0, P1_4);  // Call the AD9850 Library, AD9851 pins for CLOCK, LOAD, DATA and RESET

LCD_5110 myScreen(P2_3,    // Chip Select *
         P1_6,    // Serial Clock *
         P2_5,    // Serial Data *
         P2_4,    // Data/Command *
         NULL,    // Reset *
         P1_7,    // Backlight
         NULL);  // Push Button 0

//******************************************************************
// Defining pins mode
// Encoding the WSPR sequence

void setup() {
  pinMode(PTT_key, INPUT_PULLUP);

  myDDS.begin();

  pinMode(ANALOG_BUTTONS, INPUT);

  myScreen.begin();
  myScreen.setBacklight(1);

  myScreen.setFont(1);
  myScreen.text(0, 0, "sVFO");
  myScreen.text(0, 2, "AD9850");
  myScreen.setFont(0);
  myScreen.text(0, 4, "v1.00 - XV4Y");
  myScreen.text(0, 5, "Init...");

  delay(1000);

  myDDS.reset();

  myDDS.SetFrequency( frequency_A, 0, false );

  digitalWrite( PTT_key, LOW );

};

//******************************************************************
// Here starts the actual sequence sending

void loop() {
    myScreen.clear();
    myScreen.setBacklight(1);
    myScreen.setFont(1);
    if (vfo == 0) {
      myScreen.text(0, 0, "VFO A");
      myDDS.SetFrequency( frequency_A, 0, false );
    } else {
      myScreen.text(0, 0, "VFO B");
      myDDS.SetFrequency( frequency_B, 0, false );
    };

    myScreen.setFont(0);
    display_freq (frequency_A, 3);
    display_freq (frequency_B, 5);

    while (read_buttons()==5 || read_buttons()==4 || read_buttons()==2) delay(10); // Debounce except for UP/DWN

    while (1) {
      // Update the frequencies display
      if (multiplier > 5) {
        aff_multiplier = multiplier + 2;
      } else if (multiplier > 2) {
        aff_multiplier = multiplier + 1;
      } else {
        aff_multiplier = multiplier;
      };
      myScreen.text(0, 4, "          ");
      if (vfo == 0) {
        myScreen.text(9-aff_multiplier, 4, "^");
      } else {
        myScreen.text(9-aff_multiplier, 4, "v");
      }
      display_freq (frequency_A, 3);
      display_freq (frequency_B, 5);

      // Read the analog buttons input
      if(read_buttons()==1) {            // Up we increase frequency
        delay(200);  // Debounce
        if (vfo == 0) {
          frequency_A = frequency_A + powf(10,(float)multiplier);
        } else {
          frequency_B = frequency_B + powf(10,(float)multiplier);
        };
#if defined AUTO_VALID
        break;
#endif

      } else if (read_buttons()==3) {    // Down we decrease frequency
        delay(200);  // Debounce
        if (vfo == 0) {
          frequency_A = frequency_A - powf(10,(float)multiplier);
        } else {
          frequency_B = frequency_B - powf(10,(float)multiplier);
        };
#if defined AUTO_VALID
        break;
#endif

      } else if (read_buttons()==2) {    // Left we increase multiplier
        debounce = millis();
        while (read_buttons()==2) {  //Debounce
          if ((millis()-debounce)>1000) {  // Long press we do "Band UP"
            freq_select++;
            if (freq_select > 14) freq_select = 0;
            if (vfo == 1) frequency_B = frequencies[freq_select]; else frequency_A=frequencies[freq_select];
            multiplier--;
            break;
          };
        };
        multiplier++;
        if (multiplier > 8) multiplier = 8;

      } else if (read_buttons()==4) {    // Right we decrease multiplier
        debounce = millis();
        while (read_buttons()==4) {  //Debounce
          if ((millis()-debounce)>1000) {  // Long press we do VFO A=B
            if (vfo == 1) frequency_A = frequency_B; else frequency_B=frequency_A;
            multiplier++;
            break;
          };
        };
        multiplier--;
        if (multiplier < 0) multiplier = 0;

      } else if (read_buttons()==5) {    // OK we go out
        debounce = millis();
        while (read_buttons()==5) {  //Debounce
          if ((millis()-debounce)>1000) {  // Long press we switch VFO A/B
            if (vfo == 1) vfo=0; else vfo=1;
            break;
          };
        };
        break;   // Short press we just leave the loop so the frequency is transmitted to the AD9850
      }

      // Check if we are transmitting split (momentaneous VFO A->B switch)
      if (saved_PTT != digitalRead(PTT_key)) {
        saved_PTT = digitalRead(PTT_key);
        if (vfo == 1) vfo=0; else vfo=1;
        break;
      };
    }

};

//******************************************************************
// Display the frequency
void display_freq (unsigned long freq, char ligne) {
  myScreen.text(10, ligne, " Hz ");
  chaine_txt[5] = 0x00;
  chaine_txt[4] = 0x30 + (((freq)/1)%10);
  chaine_txt[3] = 0x30 + (((freq)/10)%10);
  chaine_txt[2] = 0x30 + (((freq)/100)%10);
  chaine_txt[1] = '.';
  chaine_txt[0] = 0x30 + (((freq)/1000)%10);
  myScreen.text(5, ligne, chaine_txt);
  chaine_txt[5] = 0x00;
  chaine_txt[4] = 0x30 + (((freq)/10000)%10);
  chaine_txt[3] = 0x30 + (((freq)/100000)%10);
  chaine_txt[2] = '.';
  chaine_txt[1] = 0x30 + (((freq)/1000000)%10);
  chaine_txt[0] = 0x30 + (((freq)/10000000)%10);
  myScreen.text(0, ligne, chaine_txt); 
}

//******************************************************************
// Display a 2 digits number
void display_number (byte number, char column, char ligne) {
  chaine_txt[2] = 0x00;
  chaine_txt[1] = 0x30 + (number%10);
  chaine_txt[0] = 0x30 + ((number/10)%10);
  myScreen.text(column, ligne, chaine_txt);
}

//******************************************************************
// Return a button value depending on the analog reading
byte read_buttons () {
  int value = analogRead(ANALOG_BUTTONS);
  if ( value<(1+Analog_Noise) ) {
    return 1;
  } else if ( value<(78+Analog_Noise) ) {
    return 2;
  } else if ( value<(146+Analog_Noise) ) {
    return 3;
  } else if ( value<(205+Analog_Noise) ) {
    return 4;
  } else if ( value<(255+Analog_Noise) ) {
    return 5;
  } else {
    return 0;
  }
}

Vidéos de mesure de la sensibilité d’un transceiver Bitx

Nicolae Fieraru a continué ses expérimentations et mesures autour du design de Farhan VU2ESE. Cette fois-çi il s’est attaqué à caractériser le bruit de fond de son Bitx version 3 pour la bande des 40 mètres à l’aide de la ligne d’appareil de laboratoire Rodhe et Schwarz dont il dispose. Ces tests montre au passage l’excellente sensibilité du Bitx et le silence de sa chaîne de réception.

Le signal est bien net dans le haut-parleur si l’amplitude est à 0,5µV (-113dBm) et la limite basse (où le signal est nettement couvert par le bruit) est à 0,2µV (-121dBm).

Le premier transistor de la chaîne de réception HF est un  BC547B. Le filtre à quartz a une bande-passante à 3dB de  2,5kHz. Si la bande passante était réduite (pour la télégraphie), la sensibilité s’améliorerait.

Video mesure bruit Bitx40 (http://www NULL.youtube NULL.com/watch?v=KH3QcbfSOUA)

J’ai téléchargé une nouvelle vidéo ou je réduis le niveau du générateur de signal HF au plus bas niveau, -144dBm ou 14nV. Il y a juste quelques traces d’une tonalité sortant du haut-parleur, mais je ne crois pas que ce soit exploitable. Le troisième transistor du VFO est retiré du circuit-imprimé et une résistance de 1kΩ insérée entre la base et le collecteur, en parallèle avec celle du schéma (le niveau de sortie est toujours acceptable mais le signal du VFO est moins distordu).

Au passage, la dernière modification demande à être validée par des tests de réjection de signal adjacent de fréquence image car en principe les mélangeurs à diodes du Bitx aiment bien être alimentés par un signal carré pour avoir les meilleures performances.

Deuxième vidéo mesure bruit Bitx40 (http://www NULL.youtube NULL.com/watch?v=q2v4Q69bs8g)

Amplificateur linéaire G6LBQ pour le Bitx multibande

Amplificateur HF G6LBQ (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2013/02/HF_Linear_MK2 NULL.png)Sur le groupe dédié à ses variations multibandes du Bitx, Andy G6LBQ vient de publier les détails de son nouvel amplificateur. Celui-ci utilise un driver avec RD16HHF1 et un push-pull de 2 RD16HHF1 pour sortir entre 10 et 20 Watts linéaires. L’adaptation d’impédance en entrée est faite part un filtre en Pi pour améliorer les performances. Tous les renseignements peuvent être obtenus sur le groupe Yahoo de G6LBQ (http://uk NULL.groups NULL.yahoo NULL.com/group/G6LBQ/).

Schéma amplificateur linéaire G6LBQ (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2013/02/G6LBQ_HF_Linear_Schematic NULL.jpg)

Mesure de bruit de phase dans des oscillateurs

Bruit de phase VFO Bitx20 - Nicolae (http://xv4y NULL.radioclub NULL.asia/2013/01/03/mesure-de-bruit-de-phase-dans-des-oscillateurs/farhan_bitx20/)Nicolae, après s’être penché aux mélangeurs équilibrés du Bitx (http://xv4y NULL.radioclub NULL.asia/2012/12/28/comparaison-de-melangeurs-a-diodes-om-et-commerciaux/) en les comparant à d’autres composants commerciaux, s’est maintenant attaqué au VFO mis au point par Farhan VU2ESE. Il a donc effectué une série de mesure de bruit de phase d’abord sur un générateur de signal Rohde & Schwarz, puis sur 3 VFO (http://users NULL.tpg NULL.com NULL.au/nfieraru/Electronics/RF_Oscillators/Phase%20Noise%20in%20RF%20Oscillators NULL.htm) dont celui du Bitx et deux autres issus de sources diverses. Les résultats sont surprenants puisque l’oscillateur du Bitx, bien que conçu de manière un peu empirique par VU2ESE, présente de très belles caractéristiques. Le bruit de phase est même meilleur que celui du générateur de laboratoire, ce qui n’est pas si étonnant pour un oscillateur à circuit LC comparé à un synthétiseur mais reste très flatteur. Le VFO présente l’inconvénient d’avoir un niveau d’harmoniques très élevé. Elles sont en parties filtrées dans le transceiver et surtout le mélangeur à diode demande lui à être alimenté par un signal rectangulaire ou du moins avec des pentes abruptes pour fonctionner de manière optimale. Tout dépend donc de vos besoins…

Au passage, l’article sur les mélangeurs (http://users NULL.tpg NULL.com NULL.au/nfieraru/Electronics/RF_Mixers/Double%20Balanced%20Mixers NULL.htm) a été complété avec les mesures de compression à 1dB qui sont encore favorables au mélangeur avec diodes 1N4148…

Comparaison de mélangeurs à diodes OM et commerciaux

Mélangeur équilibré à diodes (http://xv4y NULL.radioclub NULL.asia/2012/12/28/comparaison-de-melangeurs-a-diodes-om-et-commerciaux/dsc_1706s/)Sur le groupe Yahoo Bitx, Nicolae a partagé d’intéressantes mesures qu’il a fait de manière très rigoureuse sur différents mélangeurs doublement équilibrés à diodes. Deux étaient des mélangeurs de fabrication personnelle avec un transformateur sur un noyau de ferrite binoculaire ainsi que 4 diodes 1N4148 ou 4 diodes Schottky 1N5711 et deux étaient des circuits du commerce, le HSMS-2829 de chez Agilent ou le ADE-1 de chez Mini-Circuits.

Les résultats intégraux des mesures sont disponibles en ligne (http://users NULL.tpg NULL.com NULL.au/nfieraru/Electronics/RF_Mixers/Double%20Balanced%20Mixers NULL.htm) mais en voici un bref résumé. Tout d’abord, dans des fréquences HF, avec un niveau de signal OL suffisant pour les diodes choisies (7dBm pour des 1N4148), les circuits de fabrication OM n’ont rien à envier à ceux du commerce. Les différences sont en général de l’ordre de 1dB et ne feront pas la différence dans un circuit à usage amateur. La seule mesure “négative” est celle de la réjection du signal HF sur le port IF (seulement 30dB dans les circuits OM), or en général le mélangeur est suivi par un filtre à quartz qui éliminera très efficacement ce signal HF, c’est donc un faux problème.

Mesures sortie IF mélangeur 1N4148 (http://xv4y NULL.radioclub NULL.asia/2012/12/28/comparaison-de-melangeurs-a-diodes-om-et-commerciaux/dsc_1690_1n4148_if_out/)Ce qui conditionne beaucoup les performances des montages OM c’est l’appariement des diodes et/ou l’équilibrage. Nicolae a noté qu’en intervertissant les positions des mêmes quatre diodes 1N4148 dans un mélangeur, les niveaux d’isolation entre ports pouvaient différer de 20dB! 20dB c’est énorme, mais ce qui est rassurant c’est qu’au pire l’isolement était de 50dB, ce qui est loin d’être mauvais, à 70dB c’est parfait. L’avantage des mélangeurs du commerce c’est que cet appariement de composants est déjà fait à l’usine. L’ajout d’un potentiomètre pour équilibrer le mélangeur peut aussi être une solution, mais l’OM en recherche de performance devra bien choisir ses diodes. Nicolae s’est d’ailleurs amusé à mettre une diode 1N5711 au milieu de trois 1N4148 pour voir…

A ceux qui se pose la question du choix des 1N4148 ou 1N5711, les différences de performances sont apparemment minimes. Toutefois, mais là les mesures n’ont pas encore été publiée, l’IP3 du mélangeur à 1N4148 devrait être bien meilleur car ces diodes demandent un niveau d’injection de l’oscillateur local plus élevé à cause de leur tension de seuil plus élevé. Un rapport de mesures complet devrait venir début 2013…

Librairie pour piloter un DDS AD9850 avec un LaunchPad/MSP430 ou un Arduino

[GTranslate]

Je partage avec vous un de mes premiers résultats dans la mise au point d’une balise WSPR autonome agile avec générateur de signal à DDS (http://xv4y NULL.radioclub NULL.asia/boutique/?slug=product_info NULL.php&products_id=33). Voici en effet une petite librairie qui simplifiera vos projets pour piloter un DDS de chez Analog Devices comme le AD9850. Vous pouvez aussi facilement concevoir un VFO pour vos montages personnel Bitx (http://xv4y NULL.radioclub NULL.asia/category/ham-radio/materiel/bitx/) ou Bingo.

Cette librairie est assez simple puisqu’elle comporte quelques fonctions pour initialiser le circuit et lui programmer une fréquence. Un paramètre permet de passer le circuit en mode Power Down et de le réveiller au cas où. Cela permet d’économiser de l’énergie et même de faire une forme de CW si votre DDS génère le signal directement.

La communication se fait en mode série via 4 broches d’un micro-contrôleur MSP430G2553 par exemple. Bien entendu il faut aussi fournir l’alimentation et la masse. Fait intéressant, l’AD9850 est très flexible et supporte 3,3V ou 5V pour son alimentation. Comme la librairie est aussi très simple et n’utilise qu’un mode de communication logicielle elle est virtuellement portable sur toutes les familles de micro-contrôleurs. Le code est écrit pour les environnement de développements basés sur Wiring comme par exemple Arduino ou Energia.

Vous pouvez télécharger la librairie complète sur la page de téléchargements (http://xv4y NULL.radioclub NULL.asia/boutique/docs/).

Le code pour le fichier de header AD9850.h

/*
 AD9850.h - Library for adding simple AD9850 control capabilities on MSP430

 Copyright 2012 Yannick DEVOS under GPL 3.0 license
 Any commercial use or inclusion in a kit is subject to author approval

 ====
 Revision history :
 v1.00    2012-12-16
 First release

 ====
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You can download a copy of the GNU General Public License at <http://www.gnu.org/licenses/>

 ///////////////////////////////// How to use the lib

 * Create an instance of the object with the pin for CLOCK, LOAD, DATA and RESET

 AD9850 myDDS (P1_5, P2_0, P2_1, P2_2);	 Example for LaunchPad

 * Initialize the AD9850 and do a reset

 myDDS.begin();
 myDDS.reset();

 */

// Core library
#if defined (__AVR_ATmega328P__) || defined(__AVR_ATmega2560__) // Arduino specific
#include "WProgram.h" // #include "Arduino.h" for Arduino 1.0
#elif defined(__32MX320F128H__) || defined(__32MX795F512L__) // chipKIT specific 
#include "WProgram.h"
#elif defined(__AVR_ATmega644P__) // Wiring specific
#include "Wiring.h"
#elif defined(__MSP430G2452__) || defined(__MSP430G2553__) || defined(__MSP430G2231__) // LaunchPad specific
#include "Energia.h"
#elif defined(MCU_STM32F103RB) || defined(MCU_STM32F103ZE) || defined(MCU_STM32F103CB) || defined(MCU_STM32F103RE) // Maple specific
#include "WProgram.h"	
#endif

// ensure this library description is only included once
#ifndef AD9850_h
#define AD9850_h

// library interface description
class AD9850
{
	// user-accessible "public" interface
public:
	AD9850(uint8_t pinClock, uint8_t pinLoad, uint8_t pinData, uint8_t pinReset);
	void begin();
	void reset();
	void SetFrequency(unsigned long frequency, boolean powerdown);	// Set the frequency and send PowerDown command if needed
	// A few private methods
private:
};

#endif

Le code pour le fichier de déclaration des routines AD9850.cpp

/*
 AD9850.h - Library for adding simple AD9850 control capabilities on MSP430

 Copyright 2012 Yannick DEVOS under GPL 3.0 license
 Any commercial use or inclusion in a kit is subject to author approval

 Based on work by G7UVW

 ====
 Revision history :
 v1.00    2012-12-16
 First release

 ====
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You can download a copy of the GNU General Public License at <http://www.gnu.org/licenses/>

 */

// include this library's description file
#include <AD9850.h>
//#include <legacymsp430.h>

#define DDS_CLOCK 125000000

// Constructor /////////////////////////////////////////////////////////////////
uint8_t _DDSpinClock;
uint8_t _DDSpinLoad;
uint8_t _DDSpinData;
uint8_t _DDSpinReset;

AD9850::AD9850(uint8_t pinClock, uint8_t pinLoad, uint8_t pinData, uint8_t pinReset)
{
	_DDSpinClock = pinClock;
	_DDSpinLoad = pinLoad;
	_DDSpinData = pinData;
	_DDSpinReset = pinReset;

};

// Methods /////////////////////////////////////////////////////////////////

void AD9850::begin()
{
    pinMode (_DDSpinClock, OUTPUT); 
    pinMode (_DDSpinLoad,  OUTPUT); 
    pinMode (_DDSpinData,  OUTPUT); 
    pinMode (_DDSpinReset, OUTPUT);

	digitalWrite(_DDSpinReset, LOW);
	digitalWrite(_DDSpinClock, LOW);
	digitalWrite(_DDSpinLoad, LOW);
	digitalWrite(_DDSpinData, LOW);		
}

void AD9850::reset()
{
	//reset sequence is:
	// CLOCK & LOAD = LOW
	//  Pulse RESET high for a few uS (use 5 uS here)
	//  Pulse CLOCK high for a few uS (use 5 uS here)
	//  Set DATA to ZERO and pulse LOAD for a few uS (use 5 uS here)

	// data sheet diagrams show only RESET and CLOCK being used to reset the device, but I see no output unless I also
	// toggle the LOAD line here.

    digitalWrite(_DDSpinClock, LOW);
    digitalWrite(_DDSpinLoad, LOW);

	digitalWrite(_DDSpinReset, LOW);
	delay(5);
	digitalWrite(_DDSpinReset, HIGH);  //pulse RESET
	delay(5);
	digitalWrite(_DDSpinReset, LOW);
	delay(5);

	digitalWrite(_DDSpinClock, LOW);
	delay(5);
	digitalWrite(_DDSpinClock, HIGH);  //pulse CLOCK
	delay(5);
	digitalWrite(_DDSpinClock, LOW);
	delay(5);
	digitalWrite(_DDSpinData, LOW);    //make sure DATA pin is LOW

	digitalWrite(_DDSpinLoad, LOW);
	delay(5);
	digitalWrite(_DDSpinLoad, HIGH);  //pulse LOAD
	delay(5);
	digitalWrite(_DDSpinLoad, LOW);
	// Chip is RESET now
}

void AD9850::SetFrequency(unsigned long frequency, boolean powerdown)
{
	unsigned long tuning_word = (frequency * 4294967296 ) / (DDS_CLOCK*10);  // As frequency is in tens of Hertz, we need to multiply by 10
	digitalWrite (_DDSpinLoad, LOW); 

	shiftOut(_DDSpinData, _DDSpinClock, LSBFIRST, tuning_word);
	shiftOut(_DDSpinData, _DDSpinClock, LSBFIRST, tuning_word >> 8);
	shiftOut(_DDSpinData, _DDSpinClock, LSBFIRST, tuning_word >> 16);
	shiftOut(_DDSpinData, _DDSpinClock, LSBFIRST, tuning_word >> 24);
	if (powerdown)
		shiftOut(_DDSpinData, _DDSpinClock, LSBFIRST, B00000100);	// If powerdown is true then send PowerDown command
	else
		shiftOut(_DDSpinData, _DDSpinClock, LSBFIRST, 0x0);

	digitalWrite (_DDSpinLoad, HIGH); 
}

Le Bitx 20 portatif de PE1JXI

Harrie de PE1JXI a réalisé une version très personnelle du transceiver Bitx 20. Tout d’abord il n’est parti d’aucun circuit imprimé existant mais à réalisé le sien sur des cartes perforée pour en améliorer la compacité. Ensuite, il a usiné lui même un superbe boîtier dont il a fait les traitements de surfaces.

Le résultat est un superbe transceiver HF BLU alimenté par batteries, au format handheld ou talkie-walkie. L’ensemble fonctionne parfaitement bien émission-réception avec un look extérieur très professionnel. Tout le travail et le résultat sont visible sur la vidéo ci-dessous. Les autres vidéos du même auteur montrent ses autres incarnation de l’architecture Bitx.

Video du Bitx portatif de PE1JXI (http://www NULL.youtube NULL.com/watch?v=QqyVs-ci3QA)

Un Bitx multibandes HF-VHF et multimodes

BITX par F8VOA (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2012/11/BITX-HOOFDPRINT-3 NULL.jpg)Tel est le projet de John M0JJD : construire un transceiver multibandes HF-VHF et multimodes BLU-CW-FM autour de l’architecture du Bitx. Il faut dire que les performances et la flexibilité du design sont des atouts indéniables. Bâti autour de solutions techniques simples mais éprouvées, l’architecture mise au point originellement  par Ashar VU2ESE (http://www NULL.phonestack NULL.com/farhan/bitx NULL.html) peut être adaptée à tous les besoins. Comme solutions potentiellement retenue par John on peut noter un 74HCS4053 pour faire la commutation des filtres de bande en réception et surtout l’utilisation d’un Si571 (et non Si570) comme VFO car on peut lui fournir directement un signal audio pour qu’il produise un signal modulé en NBFM. Ceci n’est qu’un projet et pas mal de travail est à réaliser pour que les amplificateurs bidirectionnels des premiers étages laissent passer un signal VHF (choix des transistors) et que le premier mélangeur équilibré à diodes se comporte bien sur toute la bande souhaitée. Toutefois, le défi est suffisamment intéressant pour être noté.

Je l’ai déjà citée, mais si vous souhaitez vous mettre à la construction personnelle d’un Bitx (et non un kit), mis à part le groupe Yahoo dédié, la page qui contient les informations les plus détaillées aujourd’hui est celle de F8VOA (http://www NULL.qsl NULL.net/f8voa/Bitx%20presentation NULL.html) dont je conseille la lecture.

Filtre Notch audio pour vos réalisations personnelles

J’avais déjà consulté plusieurs fois le site de DF4ZS quand je cherchais à me fabriquer un compresseur de modulation BLU, mais je ne sais pourquoi j’étais passé à côté de ce montage. Il est à la fois simple techniquement et bien conçu. La documentation étant bien détaillée, l’ajouter dans vos récepteur de fabrication OM devrait être simple.

C’est vrai qu’avec des récepteurs fait maison on peut atteindre des performances tout à fait honorables si on reste sur un montage monobande et qu’on soigne la réalisation. Par contre là où la différence se fait vite sentir, surtout avec les postes commerciaux modernes à DSP sur la fréquence intermédiaire, c’est sur les filtres et traitements permettant de lutter contre les interférences et signaux indésirables.

Moi-même, sur mon Bitx, j’ai rapidement ajouté un filtre passe-bas à base de MAX293 (http://xv4y NULL.radioclub NULL.asia/2011/07/06/bitx-16-essais-en-wspr/) qui a littéralement transformé le récepteur et le rend vraiment utilisable pour de longues sessions d’écoutes CW ou BLU et du trafic DX en digimodes. Un MAX293 offre en principe 80dB de réjection ultime, comparable aux performances des postes commerciaux qui vont à plus de 90dB. Le circuit de filtre Notch que nous propose DF4ZS (http://jwm NULL.de/afu/notch NULL.htm) est un peu moins sélectif (mais avec un “creux” théorique de 46dB tout de même) et peut être commuté en filtre passe-bande ou coupe-bande (notch) ce qui lui donne une souplesse d’utilisation non négligeable.

Ce circuit est prévu pour être inséré dans la ligne BF de votre récepteur, avant l’amplificateur de sortie. Attention à ce que le niveau du signal soit toutefois suffisant pour ne pas être gêné par le bruit ajouté. Si vous ne voulez pas modifier votre récepteur, il peut sans problème être placé en sortie, mais un ampli audio tel qu’un LM380 ou LM386 sera nécessaire. Notez aussi que si votre récepteur comporte une CAG (ou AGC) sur la fréquence intermédiaire, ce circuit audio ne pourra pas empêchée qu’elle réagisse aux signaux perturbateurs trop puissants. Sur les montages persos, une commande de gain manuelle ou une AGC audio débrayable sont parfois de bons choix si on aime bricoler…

Filtre Notch DF4ZS (http://jwm NULL.de/afu/notch NULL.htm)

Je n’ai pas personnellement testé ce circuit, mais sa simplicité de mise en oeuvre et son faible coût m’incitent à y penser comme un ajout à venir probable dans mon Bitx. Les réalisations de DF4ZS étant réputée, il n’y a pas de raisons pour que celle-ci fasse exception à la règle. Si vous, vous avez l’occasion de le tester sur le terrain, n’hésitez pas à me laisser un message et partager votre expérience avec les autres lecteurs.