Being a DIY hamradio, I always needed a good signal generator for HF bands and an oscilloscope too. After long debates with my lovely wife, I got a pass for a Siglent oscilloscope but not the SigGen, hihi ! So, silently decided to build my own SigGen in small increments not willing to see my wife raising up her menace eyebrow ! Step by step I start developing a good schematic, PCB’s and proceed to “Get the job DONE !”
As usual, software will be open source on Github, feel free to make a better device !
Begin.test(4xHMC472a);
S9+60dB carrier at the input;
Loop code to cycle 30dB dB for each divider;
Almost 120dB variable digital ATT;
A critical capacitor array not soldered yet;
Some shady solderings have to be reflow;
void happy(String(input)){
Serial.println("I feel good !")
}
happy("It is working, it is working !!!!") ;
Magic smoke, it worth the effort.
After a quick chat with Psemi, it become clear that I did not properly read datasheet. Digital input cannot exceed 3.6 V for 5V Vcc ! Shame on me
First light, I successfully addressed PE4312 via MCP23008.
PE4312 is quite a nice one, apart some small insertion attenuation easy to compensate, the ATT is quite precise !
Again, Universe forces conspired to make a bigger mess than previous one !
Hello folks !
Ditched AGC auto level but opted for DAC via substractor OPAMP to control output voltage for a steady level. Also, with eye glasses I’ ve detected that AD603 out impedance is not 50 but 500 ohms, that only coz THD was way above normal and had to read datasheet once again. Stupid I know, but mistakes are making life greater ! Never had eye glasses in 48 years, but that time has come unfortunately !
Covering a 31.5 dB attenuation range in 0.5 dB steps, high linearity from DC to 3.8 GHz. Only 30dB range will be used , to ease Arduino computation.
A simple not expensive AD9850 will be used. High level of harmonics above 35 Mhz will be filtered with a 9-11 poles low pass filter.
To get a good range between S1 and S9+60 and above, a well designed adjustable 120 dB attenuator is needed. For this purpose, 4 x HMC472 will be used.
While generating frequencies between 1 to 30 Mhz, the AD8950 output signal will vary as amplitude. To overcome this, I will be using a DAC combined with AD603 to produce a steady 50 mV R.M.S. output signal before ATT network.
To get the best from this design, a well PCB is needed. Shielding, ground impedance, VCC and signal isolation, there are many things involved to get a good DIY Lab Tool. I am confident I can overcome all above !
Cannot build a valuable SigGen today without looking good also ! A high shielded Arduino and Nextion display will be used to drive this beast on, also will have to be as EMI isolated as humanly possible !
Next logical step would be to generate a clean signal using AD8950 sine output + high grade Low Pass filter followed by Auto Level circuitry.
This is a code sample for arduino to compute 0-120dB value into 4x 6 bit dividers truth table
// HMC472 Digital pins Truth table up to 31.5 dB
// ATT 16 – ATT8 – ATT4 – ATT2 – ATT1 – ATT0.5 – Value
// High High High High High High 0 dB
// High High High High High Low 0.5 dB
// Since this chip has a reversed Truth table, in order to write correct bits into dividers we compute bits in old fashion way then we negate values at the end
int debug = 1 ; // set 1 to enable serial console debugging. Disable it when done as it slows down computing time
float att = 0.5 ; // value in dB
int a = 0 ;
int b = 0 ;
int c = 0 ;
float d = 0 ;
int num;
int bit_0 ;
int bit_1 ;
int bit_2 ;
int bit_3 ;
int bit_4 ;
int bit_5 ;
String byte_A ;
String byte_B ;
String byte_C ;
String byte_D ;
void setup()
{
Serial.begin(9600);
compute() ;
if (debug == 1){debuging();}
}
void compute()
{
int times = att / 30 ;
if (times == 4) {
a = 30 , b=30, c = 30, d = att – (a + b +c) ;
}
if (times == 3) {
a = 30 , b = 30, c = 30, d = att – (a + b +c) ;
}
if (times == 2) {
a = 0 , b = 30, c = 30, d = att – (a + b +c) ;
}
if (times == 1) {
a = 0 , b = 0, c = 30, d = att – (a + b +c) ;
}
if (times == 0) {
a = 0 , b = 0, c = 0, d = att – (a + b +c) ;
}
num = a *2 ;
bit_0 = bitRead(num, 5);
bit_1 = bitRead(num, 4);
bit_2 = bitRead(num, 3);
bit_3 = bitRead(num, 2);
bit_4 = bitRead(num, 1);
bit_5 = bitRead(num, 0);
byte_A = String(!bit_0) + “,” + String(!bit_1) + “,” + String(!bit_2) + “,” + String(!bit_3) + “,” + String(!bit_4) + “,” + String(!bit_5);
num = b *2 ;
bit_0 = bitRead(num, 5);
bit_1 = bitRead(num, 4);
bit_2 = bitRead(num, 3);
bit_3 = bitRead(num, 2);
bit_4 = bitRead(num, 1);
bit_5 = bitRead(num, 0);
byte_B = String(!bit_0) + “,” + String(!bit_1) + “,” + String(!bit_2) + “,” + String(!bit_3) + “,” + String(!bit_4) + “,” + String(!bit_5);
num = c *2 ;
bit_0 = bitRead(num, 5);
bit_1 = bitRead(num, 4);
bit_2 = bitRead(num, 3);
bit_3 = bitRead(num, 2);
bit_4 = bitRead(num, 1);
bit_5 = bitRead(num, 0);
byte_C = String(!bit_0) + “,” + String(!bit_1) + “,” + String(!bit_2) + “,” + String(!bit_3) + “,” + String(!bit_4) + “,” + String(!bit_5);
num = d *2 ;
bit_0 = bitRead(num, 5);
bit_1 = bitRead(num, 4);
bit_2 = bitRead(num, 3);
bit_3 = bitRead(num, 2);
bit_4 = bitRead(num, 1);
bit_5 = bitRead(num, 0);
byte_D = String(!bit_0) + “,” + String(!bit_1) + “,” + String(!bit_2) + “,” + String(!bit_3) + “,” + String(!bit_4) + “,” + String(!bit_5);
// Here we should call 4 different instances of MCP23008 to write values into dividers
}
void debuging()
{
Serial.println(“Computing values for ” + String(att) + “dB”);
Serial.println(“Divider A attenuation = ” + String(a) + “dB”);
Serial.println(“Divider B attenuation = ” + String(b) + “dB”);
Serial.println(“Divider C attenuation = ” + String(c) + “dB”);
Serial.println(“Divider D attenuation = ” + String(d) + “dB”);
//////////////////////////////////////////////////////////////////////////
Serial.println(“writting divider A with ” + byte_A );
Serial.println(“writting divider B with ” + byte_B );
Serial.println(“writting divider C with ” + byte_C );
Serial.println(“writting divider D with ” + byte_D );
Serial.println(“Compute time = ” + String(millis()) + ” miliseconds” );
}
void loop()
{
delay(1000000000) ; // do nothing here
}
