A simple software to control the Si5351A clock generator chip

A fellow radio amateur who visited my website gave me a hint for a very cheap module that is capable of generating rf sginals up to 200 MHz. It is the well-known Si5351A clock generator chip made by Silicon Labs (datasheet).It is available by ADAFRUIT mounted to a breakout board using 0.1″ conventional spacing. The chip itself is very small, so by using the ADAFRUIT stuff you don’t have to bother soldering SMDs to a PCB. (Link to ADAFRUIT). The chip is designed for 3.3V supply, on the Adafruit board you can find circuits to make this chip usable for 5V supply and 5V control lines. So it is compatible to standard 5V digital equipment.


(Picture courtesy ADAFRUIT)

In contrast to the DDS chips I have been using before this one produces square waves. But especially for mixer purposes in a radio this can be an advantage because mixers generally are well controlled by square waves. And due to the mandatory post-mixer filtering circuitry harmonics are easily suppressed.

The Si5351 generator is intended to replace clock sources of all kinds, build PLL generators etc. It is fully programmable via I2C bus, in ATMega language called “TWI” (two wire interface).

My software does not use the Arduino code or other libraries, all TWI functions are written into the file to make understanding more easy without the neccessity to watch different files.

Basic guidelines for programming

Programming the Si5351 is a little bit more complicated than to set the frequency of the AD9xxxx DDS chips by Analog Devices that are well mentioned on my website. The programming of the PLL(s) and the synthesizer(s) is described in AN619 of SiLabs (Link). There are 2 steps to get the desired frequency out of the module.

Step 1: Set the PLL to a basic frequency (in my code to f=900 MHz)

Step 2: Divide this frequency using a “MultiSynth” divider to the desired output frequency using a set of equations given in AN619 and send this to one of the outputs (CLK0 to CLK2 with the Si5351A).

For handling step 1 you can see the function void si5351_start(void) in the code. Step 2 is done by the function void si5351_set_freq(int synth, unsigned long freq). Both functions look similar due to the fact that basic arithmetics do not differ very much. They got in common that you first have to calculate a set of integer values and subsequently write them into a larger number of registers of the Si5351. To understand this more easily I have written the register numbers into the code. It is highly recommended to watch the register table in AN619 to see the corresponding memory locations.

The software is very simple. You can generate one frequency that will be transferred to CLK0 output on the PCB. Watch the code:

/*             RF generator with Si5153 and ATMega8              */ 
/*  ************************************************************ */ 
/*  Mikrocontroller:  ATMEL AVR ATmega8, 8 MHz                   */ 
/*                                                               */ 
/*  Compiler:         GCC (GNU AVR C-Compiler)                   */ 
/*  Author:           Peter Rachow (DK7IH)                       */ 
/*  Last Change:      2017-FEB-23                                */ 
//This is an absolute minimum software to generate a 10MHz signal with 
//an ATMega8 and the SI5351 chip. Only one PLL is used and only one of  
//the 3 possible CLK output channels. Due to register loading  
//simplification the max. frequency this software can produce is 36 MHz.  
//So, the software is more for educational purposes but can be modfied  
//to get more stuff out of the chip. 
//73 de Peter (DK7IH) 
#include <inttypes.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <math.h> 
#include <avr/io.h> 
#include <avr/interrupt.h> 
#include <avr/sleep.h> 
#include <avr/eeprom.h> 
#include <util/delay.h> 
//Defines for Si5351 
#define SI5351_ADDRESS 0xC0 // 0b11000000 for my module. Others may vary! The 0x60 did NOT work with my module! 
//Set of Si5351A register addresses 
#define CLK_ENABLE_CONTROL       3 
#define PLLX_SRC                15 
#define CLK0_CONTROL            16  
#define CLK1_CONTROL            17 
#define CLK2_CONTROL            18 
#define SYNTH_PLL_A             26 
#define SYNTH_PLL_B             34 
#define SYNTH_MS_0              42 
#define SYNTH_MS_1              50 
#define SYNTH_MS_2              58 
#define PLL_RESET              177 
#define XTAL_LOAD_CAP          183 
//The unavoidable functional stuff 
int main(void); 
void wait_ms(int); 
//  TWI Declarations 
void twi_init(void); 
void twi_start(void); 
void twi_stop(void); 
void twi_write(uint8_t u8data); 
uint8_t twi_get_status(void); 
//  SI5351 Declarations 
void si5351_write(int, int); 
void si5351_start(void); 
void si5351_set_freq(int, unsigned long); 
//   TWI-Functions 
void twi_init(void) 
    //set SCL to 400kHz 
    TWSR = 0x00; 
    TWBR = 0x0C; 
    //enable TWI 
    TWCR = (1<<TWEN); 
//Send start signal 
void twi_start(void) 
    TWCR = (1<<TWINT)|(1<<TWSTA)|(1<<TWEN); 
    while ((TWCR & (1<<TWINT)) == 0); 
//send stop signal 
void twi_stop(void) 
    TWCR = (1<<TWINT)|(1<<TWSTO)|(1<<TWEN); 
void twi_write(uint8_t u8data) 
    TWDR = u8data; 
    TWCR = (1<<TWINT)|(1<<TWEN); 
    while ((TWCR & (1<<TWINT)) == 0); 
uint8_t twi_get_status(void) 
    //mask status 
    return TWSR & 0xF8; 
// Si5351A commands 
void si5351_write(int reg_addr, int reg_value) 
// Set PLLA to internal 900 MHz 
void si5351_start(void) 
  unsigned long a, b, c; 
  unsigned long p1, p2, p3; 
  // Initialize Si5351A 
  si5351_write(XTAL_LOAD_CAP,0b11000000);      // Set crystal load to 10pF 
  si5351_write(CLK_ENABLE_CONTROL,0b00000000); // Enable all outputs 
  si5351_write(PLLX_SRC, 0b00000000);          //Set PLLA and PLLB source to XTAL 
  si5351_write(CLK0_CONTROL,0b00001111);       // Set PLLA to CLK0, 8 mA output 
  si5351_write(PLL_RESET,0b10100000);          // Reset PLLA and PLLB 
  a = 36;           // Set PLL A to 900 MHz (900/25=36) 
  b = 0;            // Numerator 
  c = 0xFFFF;       // Denominator 2^16  
  //See Si5351 register map AN619! 
  p1  = 128 * a - 512; 
  p2  = 0; 
  p3  = c; 
  // Write data to MultiSynth0 registers                            REG  
  si5351_write(SYNTH_PLL_A + 0, (0xFF00) >> 8);                     //26 
  si5351_write(SYNTH_PLL_A + 1, p3 & 0xFF);                         //27   
  si5351_write(SYNTH_PLL_A + 2, (p1 & 0x00030000) >> 16);           //28 
  si5351_write(SYNTH_PLL_A + 3, (p1 & 0x0000FF00) >> 8);            //29 
  si5351_write(SYNTH_PLL_A + 4, (p1 & 0x000000FF));                 //30 
  si5351_write(SYNTH_PLL_A + 5, 0xF0 | ((p2 & 0x000F0000) >> 16));  //31 
  si5351_write(SYNTH_PLL_A + 6, (p2 & 0x0000FF00) >> 8);            //32 
  si5351_write(SYNTH_PLL_A + 7, (p2 & 0x000000FF));                    //33 
void si5351_set_freq(int synth, unsigned long freq) 
  unsigned long  a, b, c; 
  unsigned long p1, p2, p3; 
  unsigned long xtal=25000000; 
  c = 0xFFFF;  //Denominator 2^16 
  a = (unsigned long)(xtal * 36 / freq); // Set MultiSynth div ratio to 36 
  b = (unsigned long)(xtal * 36) % freq; 
  b = (unsigned long) (b * c / freq); 
  //See Si5351 register map in AN619! 
  p1  = 128 * a + (unsigned long) (128 * b / c) - 512; 
  p2  = (128 * b) - c * (unsigned long) (128 * b / c); 
  p3  = c; 
  si5351_write(synth, 0xFF);                        //Start with basic register of selected Synth 
  si5351_write(synth + 1, 0xFF);                    //+1 
  si5351_write(synth + 2, (p1 & 0x30000) >> 16);    //+2 
  si5351_write(synth + 3, (p1 & 0xFF00) >> 8);      //etc.  
  si5351_write(synth + 4, (p1 & 0xFF));     
  si5351_write(synth + 5, 0x00 | ((p2 & 0x000F0000) >> 16)); 
  si5351_write(synth + 6, (p2 & 0xFF00) >> 8);  
  si5351_write(synth + 7, (p2 & 0xFF)); 
//              M  I  S  C   
//Substitute defective _delay_ms() function in delay.h 
void wait_ms(int ms) 
    int t1, t2; 
    int dtime = (int) 137 * 8; 
    for(t1 = 0; t1 < ms; t1++) 
        for(t2 = 0; t2 < dtime; t2++) 
            asm volatile ("nop" ::); 
int main(void) 
    PORTC = 0x30;//I²C-Bus lines: PC4=SDA, PC5=SCL  
    si5351_set_freq(SYNTH_MS_0, 10000000);  //10 MHz out to CLK2 
    return 0; 

Thanks again for watching my amateur radio blog!

73 de Peter

The Micro QRP Transceiver – A pocketful of radio in SMT

Recently I thought about how small a fully functionable ham radio could be. Or to say in other words: Should it be possible to build a QRP SSB transcevier that fits into a shirt pocket?

When searching the web for very small amateur radio SSB transceivers I found Pete Juliano’s (N8QW) “Shirt pocket transceiver“. This is a really neat transceiver with 2 Watts of output as Pete says.

My goal was to achieve also 2 Watts of output but keeping the rig even smaller. This was, as I quickly recognized, only possible by replacing conventional through-hole construction by using SMD components to a wide extent. Other things that had to be done were to get an LCD with as little physical expansion as possible and to find small potentiometers for the front panel, also as small as possible.

As an LCD due to the prerequisites mentioned before I use an OLED with 0.96″ diagonal size. This display is available in SPI or I²C/TWI interface technology. Due to the fact that I²C/TWI only uses 2 control lines (which would save me some effort when wiring this) I chose this version. The rest of the transceiver is standard QRP stuff:

  • AD9835 as DDS driven by an Arduino Pro Mini board with ATMega328 uC.
  • NE602s as SSB generator, TX mixer, RX mixer and product detector
  • MC1350 as IF amp
  • Dual-Gate-MOSFET as RX preamp

The only one of the usual suspects missing in this project is the LM386 audio amplifier. This has been replaced by a push-pull audio amp with a PNP/NPN pair of bipolar transistors.

I revived the construction of my 20m-handheld transceiver just to shrink it to a size as small as possible. Underneath you can watch the final state of this project “micro transceiver”. First the outside view. It easily fits, as you can see, in one hand.

QRP micro transceiver by DK7IH - 20 meters 2 Watts SSB ins SMDT/SMD technology - outside view
QRP micro transceiver by DK7IH – 20 meters 2 Watts SSB ins SMDT/SMD technology – outside view

Now for the inside:

QRP micro transceiver by DK7IH - 20 meters 2 Watts SSB ins SMDT/SMD technology - inside view
QRP micro transceiver by DK7IH – 20 meters 2 Watts SSB ins SMDT/SMD technology – inside view

Explanation: Starting in the left upper corner you can see the AD9835 DDS mounted to a breakout board.

Going clockwise next is the receive mixer and the front end with a 40673 dual gate MOSFET transistor. On the right side there is the transmitter. First the final amplifier (push-pull technology), followed by driver and preamp. On the right bottom there is the transmitter’s BPF. Next is the ladder filter for the tx section, “north” of that the transmit mixer, ladderfilter, once again “north” you can see the balanced modulator and the mic amp fed by a shielded cable leading to the front panel.

In the center there is the latter part of the receiver, MC1350 if amp, product detector and audio amps (pre and final stage) sited in the left bottom corner.

The front panel holds the microcontroller (an Arduino Pro mini used as a native AVR without Arduino software), the 0.96″ OLED and the controls.

The transceiver interior section viewed from front:

Micro QRP SSB transceiver for 20m 14MHz by Peter (DK7IH) - front view inside
Micro QRP SSB transceiver for 20m 14MHz by Peter (DK7IH) – front view inside

And here is the full circuit of my micro transceiver:

Micro QRP SSB transceiver for the 20 meter band (14MHz) by Peter, DK7IH
Micro QRP SSB transceiver for the 20 meter band (14MHz) by Peter, DK7IH

To watch the schematic in full size click here.

The transmitter puts out 2 to 2.5 watts SSB. Applying a two-tone signal shows the following output:

Signal of my 20 meter 14 Mhz micro SSB transceiver (about 2.5 watts output)
Two-tone-signal of my 20 meter 14 Mhz micro SSB transceiver (fully driven, about 2.5 watts output)


Excursus: What about using SMDs on Veroboards?

SMDs are not only for printed circuit boards. You can also use them on the standard 2.54mm (0.1″) pitch veroboards.. When you would like to start a similar project, I strongly recommend, in addition to the standard electronic toolcase, the following working material and equipment:

  • A high quality temperature stabilized soldering station (I use a Weller WHS 40D) with a 2mm solder tip (wedge-shaped),
  • Small pairs of tweezers of various sizes,
  • A surgical magnifier (I personally use the “RidoMED” by German manufacturer Eschenbach (Link) which sells for about 320,- Euros)
  • 2 or 3 desk lights coming from various angles to you work area.

Where can I get that SMD stuff at a reasonable price?

SMD components are best bought in assortments from the well known electronic warehouses on the web. I bought for example  abt. 4000 resistors more than 50 different values) from Chinese vendors via ebay for not more than 5 USD. The same is valid for capacitors. Transistors are also on stock, for example the BC837, BC 846 and other types. ICs in SMD case that can also be purchased are the NE602,612 etc., LM386, MC1350. So, after some weeks a reliable base of SMD componenst is right at hand. For any conceivable QRP project there is enough material available to start.

Soldering SMD components

Standard Veroboards with 0.1″ spacing (2.54mm) can be used with 0603 and 0805 and other SMD parts easily. They well fit into the spaces between the dots on the veroboard.

My method of using SMDs on the veroboard: First put a little bit of solder tin to one of the dots where you want to mount the part. Fix the part with one leg/side by soldering it to the board. Then (if neccessary) readjust the component with the pair of tweezers so that it fits accurately to the board. Keep an eye on the fact that it should be sited plain on the board. If neccessary press it down with a pair of tweezers carefully while heating up the soldering point. Finally check the component from various perspectives!

After having got the correct position of the component, solder the remaining leads and control your work with a magnifying glass, a jeweller’s loupe or the surgical magnifier.

Desoldering SMD components

Desoldering is, to my opinion, easier than with through-hole components:

Parts with 2 soldering areas: Heat the leads of the component from both sides quickly by changing the side with your soldering iron. Soldering tin on both sides must be liquid. Keep the part with the pair of tweezers using your other hand. After some seconds the part will move, in most cases it will stick to the solder tip. Don’t reuse this part!  It might have become damaged by thermal stress in case of excessive heat appliance when desoldering process takes longer or by mechanical stress.

Parts with more leads (transistors etc.) : I heat  one edge of the part to desolder 2 pins. Simultanously I grap the part with the pair of tweezers and bend the leads up when the solder has melted. Then I desolder the rest of the part.

So, I hope I could give you another inpiration for building a small compact transceiver using SMDs. 73s and thanks for watching!

Peter (DK7IH)





Cheap and dirty measurement of filter response curves

When cleaning up my shack I found one of those very cheap China made DDS modules containing an AD9850 synthesizer. “Let’s do something with it!” was the decision. I connected an ATMega328 to it and wrote a very short piece of software to sweep the frequency between two edging values. This signal is sent thru a filter to get the respective response curve without taking great effort:

Measuring filter response curves with microcontroller and China made DDS modul (AD9850)
Measuring filter response curves with microcontroller and China made DDS modul (AD9850)

I connected the output of the DDS to a ladder filter I wanted to test. On my spectrum analyzer (oldie but goldie HP8558B) I got the expected outcome. But then I started thinking of those amateurs who are not the proud owners of such an instrument. So I connected the filter output to my RIGOL DS1054Z digitial scope. After some tries I was able to synchronize the DDS’ sweep time with the horizontal sweep of the scope an got the filter curve on the screen:


When you put horizontal sweep rate to a very low value you will finaly see the filter response curve. This is not very exact due to the lack of frequency readout on the scope’s x axis but it is OK if you want to check the flatness of a filter. And it is quickly done.

But due to my fascination for exact things I will trigger the scope by the microcontroller so that I can deduce a unit of khz per cm on my scope screen.

73 and thanks for watching my blog!


The software:

 /* Frequency sweeper with ATMega8 + AD9850 */
 /* ************************************************************ */
 /* Mikrocontroller: ATMEL AVR ATmega328p, 8 MHz */
 /* */
 /* Compiler: GCC (GNU AVR C-Compiler) */
 /* Autor: Peter Rachow */
 /* Letzte Aenderung: 16.11.2016 */

#include <inttypes.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <math.h> 
#include <avr/io.h> 
#include <avr/interrupt.h> 
#include <avr/sleep.h> 
#include <avr/eeprom.h> 
#include <util/delay.h>

#define F_CPU 8000000

int main(void);

 // SPI
 //Port usage
 //FQ_UD: PB0 (1) blue
 //SDATA: PB1 (2) green
 //W_CLK: PB2 (4) white
 //RESET AD9850 PD7 yellow

void set_frequency_ad9850(unsigned long);

 // SPI

//Set AD9850 to desired frequency
 void set_frequency_ad9850(unsigned long fx)
 unsigned long clk = 125000000;
 unsigned long x = 1;
 int t1;

double fword0;
 unsigned long fword1;

fword0 = (double) fx / clk * 4294967296;
 fword1 = (unsigned long) fword0;

//Send 32 frequency bits + 8 additional bits to DDS
 //Start sequence
 PORTB &= ~(1); //FQ_UD lo => Bit PD0 = 0

for(t1 = 0; t1 < 32; t1++)
 if(fword1 & x << t1)
 PORTB |= 2; //SDATA Bit PB1 setzen
 PORTB &= ~(2); //SDATA Bit PB1 löschen

//W_CLK hi
 PORTB |= 4; //Bit PB2 setzen

//W_CLK lo
 PORTB &= ~(4); //Bit PB2 löschen

//W32...W39 all bits are 0!
 PORTB &= ~(2); //SDATA Bit PB1 löschen
 for(t1 = 0; t1 Bit PD0 = 1


int main()

unsigned long fx0 = 10000000;
 int swing_f = 10000;
 int delta_f = 5;
 unsigned long fx1 = fx0 - swing_f;
 unsigned long fx2 = fx0 + swing_f;
 unsigned long f;

DDRB = 0xFF; //SPI (PB0..PB2)
 DDRD = 128;

PORTD |= 128; //Bit PD7 set
 _delay_ms(1000); //wait for > 20ns i. e. 1ms minimum time with _delay_s()
 PORTD &= ~(128); //Bit PD7 erase

 for(f = fx1; f 20ns i. e. 1ms minimum time with _delay_s()
 PORTD &= ~(128); //Bit PD7 erase


return 0;

A very compact SSB transceiver for 40 Meters with 50 watts of output power (Product detector, AF, AGC)

The demodulator section of the transceiver’s receiver starts with the product detector, which is made of another SA602. To get more audio volume a preamplifier has been added before the LM386 follows.

Homemade SSB amateur radio transceiver 40 meters (SSB demodulator, AF, AGC section)
Homemade SSB amateur radio transceiver 40 meters (SSB demodulator, AF, AGC section)

The AGC section hast got 2 crucial components: One resistor (this case 100k) and an electrolytic capacitor (in this case 100uF): They determine the time ramp for the AGC regulation curve. This means they define the response and decay time for the AGC and thus should be made easily changable for example by putting them into socket strips.

Hint: In certain cases it can be useful to add a potentiometer to give you control on the audio input of the AGC preamplifier.

Thanks for watching!

73 de Peter

A very compact SSB transceiver for 40 Meters with 50 watts of output power (IF amplifier)

The if amplifier has been slightly revised. I added a preamplifier after the 1st mixer to enhance overall gain. Due to the fact that the veroboard is crowded with the components that had already been installed, the preamplifier has been worked out in SMD technology using the reminaing space on the reverse side of the board underneath the SSB filter were still some room has been available:

IF peamplifier in SMD technology
IF peamplifier in SMD technology

This new part of the circuit  is not marked in the block diagram I’ve posted some days ago. As main amplifier of this stage, MC 1350 is used. Due to space saving reasons the tuned circuit to terminate the if amplifier IC has been made of a very smmall pig-nose core:

IF amplifier detail
IF amplifier detail

The parallel capacitor has been experimentally optimized by putting various capacitors into a 2 pin part of a socket strip and keeping the best valued. The MC1350 is gained controlled by an AGC amplifier and DC rectifier section to be described later. Please notice the correct termination of the SSB filter with 2 resistors 2.4 kOhms each.

Homemade SSB amateur radio transceiver 40 meters (IF amplifier) Homemade SSB amateur radio transceiver 40 meters (IF amplifier with bipolar transistor and MC1350)
Homemade SSB amateur radio transceiver 40 meters (IF amplifier) Homemade SSB amateur radio transceiver 40 meters (IF amplifier with bipolar transistor and MC1350)

Thanks for watching! Vy 73 de Peter (DK7IH)

A very compact SSB transceiver for 40 Meters with 50 watts of output power (Receiver front end and 1st mixer)

For my compact 40 metres transceiver there was not plenty of space for complicated circuits. So I had to find a simple but effective solution for the singe stages. Everybody knows that the first stage in the receiver’s front with the 1st mixer, which is a crucial one, determins the overall performance of the whole receiver to a wide extent. So, which mixer should I use?

Among the “standard” mixers available on the market there is one, that uses only a few external components as a mixer stage that, aside from mixing two signal, delivers a recognizable amount of gain (around 18 dBs): The well-known NE612 (aka “SA602” and other derivates).

But there is one problem: The NE602 has been developed for VHF communications where excessive signal strenghtes are not the primarly issue. On 40 metres the situation is different. Very much different. OK, even if strong in-band signals are present they won’t push the NE602 to its limits as I could find out, the problem are the extremely strong signals from broadcasters at 7.200 khz and above.The NE602 reacts with lots of spurious signals if input levels are too high. Thus, developing a front end, that is able to cope with extremely loud signals only some Kilohertz away fron the operating frequency was a challenge. Intense filtering was the key to success. Here is my solution:


Homemade SSB amateur radio transceiver 40 meters (Receiver's front end)
Homemade SSB amateur radio transceiver for40 meters (Receiver’s front end)

For extreme receiving situations with excessive out-of-band signals there is a 10dB attenuator switchable from the front panel. As I found out this is only required if you use an antenna that delivers high rf voltages in the evening from broadcast stations transmitting above 7.200 kHz (like my Deltaloop does). With my vertical antenna using the attenuator on the other hand is obsolete.

After the attenuator you can see a three-pole filter made of tuned circuits with a center frequency of about 7.100 kHz. The trick is the loose coupling between the single tuned circuits. This makes the filter extremely sharp but costs you some gain. To compensate the loss, the following stage equipped with an NPN-transistor is used. Noise figure enhancement is not the problem on 40 meters, so I did not use a FET. A bipolar transistor fills the needs.

After that another 2 tuned circuits, also extremely loosely coupled, follow. Next is the well-known SA602 mixer IC powered with the input signal from the 7MHz filtes and the DDS VFO.The input to PIN 1 and 2 of the mixer IC is symmetical which is preferably to the single ended unbalanced method seen in many other circuits.

The practical solution of the RF preamp is a flat package mounted to the side of the transceiver’s mainframe:

RF Preamp with 3-pole-filter for 7MHz
RF Preamp with 3-pole-filter for 7MHz receiver using SMD technologoy for the amplifier

You can see the antenna input from the right, an on/off switch from top (not in schematic) and the output to the 1st mixer also on the right (connected to the reverse side of the PCB).

Thanks for watching es vy 73 de Peter (DK7IH)


A very compact SSB transceiver for 40 Meters with 50 watts of output power (Overview and block diagram)

In my last article I talked about my ideas fo a new transceiver project beyond the QRP level. First pictures of cicuitry were also shown. In the meanwhile the transceiver has been finished, some minor changes had to be made and now it’s time to go to the details.

All construction objectives (compact size, sufficient output power to establish even DX contacts on 40 meters, good stability, good receive performance, rigidness for outdoor use) have been met so far as I can say. I had the rig with me, when I was on vacation on the Island of Jersey (GJ/DK7IH/P) from 12th to 19th of August this year. It was big fun operating the rig. Lots of stations were calling during the two days when I was on 40 meters. ODX was HL1AHS, OM Kun from Seoul. So, this was very nice for 50 watts and a vertical antenna made of a fishing rod.

First, to give an overview, let’s have a look on the completed transceiver. Cabinet size is 7.5 x 16 x 6 centimeters.

SSB transceiver for 40 Meters with 50 Watts of output
SSB transceiver for 40 Meters with 50 Watts of output
SSB transceiver for 40 Meters with 50 Watts of output
SSB transceiver for 40 Meters with 50 Watts of output power (by DK7IH)

As you can see, the rig is very compact in size. The block diagram gives you an overview what is inside. Receiver section is on top, DDS can be found in the center and the transmitter is sited at the bottom of the diagram. As you can see, it’s again not rocket science and SDR-virus could not strike as well. 😉

SSB transceiver for 40 Meters with 50 Watts of output (Block diagram)
SSB transceiver for 40 Meters with 50 Watts of output (Block diagram)

The next posts will describe the rig in details step by step. Proceed with the receiver’s front end.

73 de Peter