I got lazy. And so can you!
I had breadboarded the germanium leakage and true gain tester from Geofex as I finally decided to order boxes of those recently popular new-old-stock Russian germanium transistors.
Because I absolutely hate math I had put together a spread sheet with the formulas ready to go! All I had to do was punch in the two measurements - open base voltage & closed base voltage.
Well apparently that was too much work for me and I got sick of it real quick. Numbers kept changing and results were slightly different each time I retyped the measurements
So the thought occurred to me early this afternoon, can I make an arduino do it? Turns out I can! And it's surprisingly accurate in comparison to the manual method.
Devices tested in this photo are MP39B - with noted gains between 20 & 60 according to our archives around the forum.
(https://i.postimg.cc/XnnZCQGz/20211006-230153.jpg)
Before I draw up a schematic I will say that the parts in the photo are certainly overkill as the majority of both ICs & Arduino are unused. I had also kept some uneeded values in the code just in case I wanted to display them to manually to check the results against a DMM & my pre-formulated spreadsheet.
Here's my code for anyone interested. I'll try to put up a schematic tomorrow, but it's rather straight forward. The number .00488 is to convert the resolution of the 10-bit ADC @ 5 volts to the actual voltage (5/1024 = ~0.00488).
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x3F, 16, 2);
int pulsePin = 55;
int adcPin = A0;
float voltageA;
float voltageB;
float voltageLeak;
float voltageGain;
void setup() {
lcd.begin();
lcd.backlight();
pinMode(pulsePin, OUTPUT);
}
void loop() {
//read open base
digitalWrite(pulsePin, LOW);
delay(50);
voltageA = analogRead(adcPin)*.00488;
//read closed base
digitalWrite(pulsePin, HIGH);
delay(50);
voltageB = analogRead(adcPin)*.00488;
//print result
voltageGain = (voltageB-voltageA)*100;
lcd.clear();
lcd.print("TGain = ");
lcd.print(voltageGain, 1);
lcd.print(" hfe");
voltageLeak = voltageA/2472*1000000;
lcd.setCursor(0, 1);
lcd.print("Leakage = ");
lcd.print(voltageLeak, 0);
lcd.print(" uA");
}
That's it for tonight 8)
That's very cool, Kevin. 8)
Talking of cool, have you also devised a robot to pick up and connect each transistor in turn to avoid heating them up with your fingers? ;)
You had me at "lazy". :icon_wink:
Quote from: digi2t on October 07, 2021, 06:23:44 AM
You had me at "lazy". :icon_wink:
:icon_lol: :icon_lol: :icon_lol:
Quote from: bluebunny on October 07, 2021, 04:07:47 AM
Talking of cool, have you also devised a robot to pick up and connect each transistor in turn to avoid heating them up with your fingers? ;)
Okay that's a bit much :icon_lol:
Since the device updates the two measurements faster than we could and also without transferring body heat from getting near to close the base lead the measurements stabilize rather fast!
Before I go into any details about the circuit itself (sorry for so many edits here!) I'm going to see about simplifying it with a 1P2T analog switching IC and also a smaller micro controller. Time to do some shopping!
You know what they say: one man's laziness is another man's freebie! Thanks, Kevin, looking forward to it.
Outstanding! I've been looking for something useful to do with the Arduinos I have, plus a reason to compel me into digging deeper into programming. This looks like the ticket. I'm off on a long distance drive out to the coast over this weekend, but look forward to hunkering down when I return, and eagerly await the schematic.
Thanks for this Kevin. A real act of forum citizenship.
Thanks, Mark! And thank you for your kind words. Hope you have fun with it!
Worth noting for folks wanting to try this;
If you don't have an I2C display or something similar around you could simply use the Arduino IDE's serial monitor - only you can't clear it so the data just keeps stacking. A couple 3 or 4 digit segment displays and some shift registers was my first idea.
Tonight I'll verify if a buffer is necessary - used a 4049 to raise the pulse voltage for the CD4016 as it has +9v VDD for lower on-resistance. Could probably get away with +5v as the transistor measurements don't exceed a few volts. Then I'll draw up the schematic of what's on the breadboard.
I'm going to design a board that uses an ATtiny and a single analog SPST IC. TS12A4514P (https://www.mouser.com/ProductDetail/Texas-Instruments/TS12A4514P?qs=7kv20MEVUlgOnRg5FxTdIQ%3D%3D) seems like a good candidate. Just have to shop around for a display I like and an appropriate controller for it. And also means to protect the controller from >5 volts hitting the ADC from potential user error while also not mucking up the readings.
yeah, ATtiny ftw. Overkill use big boy arduino.
years of pedal building, i never build Ge Fuzz for myself. Hahaha, laugh hard to myself.
What you really need is one of these. I doubt anybody will build it. Not enuff sexy mojo.
(https://i.postimg.cc/ZBh3RYc1/TT1.gif) (https://postimg.cc/ZBh3RYc1)
(https://i.postimg.cc/ftjd04qk/TT2.gif) (https://postimg.cc/ftjd04qk)
(https://i.postimg.cc/nMpBfzMm/TT3.gif) (https://postimg.cc/nMpBfzMm)
3-page PDF https://pdfhost.io/v/YsOJNBbNM_Image2
Quote from: PRR on October 07, 2021, 09:07:56 PM
What you really need is one of these. I doubt anybody will build it. Not enuff sexy mojo.
Now that's retro 8)
Here's a quick schematic. Told ya it was straight forward!
(https://i.postimg.cc/zDg06thK/Germanium-Tester-Schem.png)
I had a late thought about the accuracy of the ADC. Since it relys on an unstable VCC voltage that isn't exactly 5 volts it isn't as accurate as most of our multimeters. But after running some tests with my Arduino Mega I feel safe saying it's close enough for this purpose. There are methods of improving the ADC of some arduinos like the Uno by utilizing a more stable internal reference. So if anyone is worried about that I suggest following one of the many tutorials on dealing with ADC accuracy. Sadly the Mega doesn't have that reference voltage. I also seen someone mention adding 4 ADC measurements & divide by 2 resulting in 4 samples averaged and displayed as an extra bit to help negate any noise from the ADC results.
For a PCB version I would use an external ADC of higher resolution with a stable reference voltage.
That polarity does not look right for a PNP?
Actually I'm not sure what that rig measures.
If you use 4066 you do not need 4049?
QuoteThat polarity does not look right for a PNP?
Actually I'm not sure what that rig measures.
If you use 4066 you do not need 4049?
Need to flip C and E.
The switch opens the base to measure leakage. It's basically RG's circuit,
http://www.geofex.com/Article_Folders/ffselect.htm
(http://www.geofex.com/FX_images/xstrtest.gif)
QuoteWhat you really need is one of these. I doubt anybody will build it. Not enuff sexy mojo.
You could do a "DMM Adaptor" version which uses a DMM to display the readings. I guess not much different to RG's ckt.
Wrong way? What do you mean? ::)
I was tired lol. Fixed. Thanks, guys!
Quote from: PRR on October 07, 2021, 11:39:49 PM
If you use 4066 you do not need 4049?
Depends on the threshold of a 4016 or 4066 running on 9 volts. I'm using a 4016 and ~4.8v from the Arduino wasn't cutting it to trigger the switch.
There's of course alternatives to a buffer. It was just the easiest thing for me to do in a pinch.
(https://i.postimg.cc/xXsJ68Kp/1-E8-BE5-E4-474-E-4603-AECF-4-A5-B808029-C8.jpg) (https://postimg.cc/xXsJ68Kp)
Paul: here's one.
This project is rad, do you think an ATTiny85 could do this?
This is my Lazy Man's Germanium tester:
https://www.amazon.com/Pocketable-Multifunctional-Backlight-Transistor-Capacitor/dp/B07X5YS1JN/ref=asc_df_B07X5YS1JN/?tag=hyprod-20&linkCode=df0&hvadid=416638923984&hvpos=&hvnetw=g&hvrand=4105942515975511802&hvpone=&hvptwo=&hvqmt=&hvdev=c&hvdvcmdl=&hvlocint=&hvlocphy=9005070&hvtargid=pla-845729973092&psc=1&tag=&ref=&adgrpid=93604202533&hvpone=&hvptwo=&hvadid=416638923984&hvpos=&hvnetw=g&hvrand=4105942515975511802&hvqmt=&hvdev=c&hvdvcmdl=&hvlocint=&hvlocphy=9005070&hvtargid=pla-845729973092
Quote from: Rob Strand on October 08, 2021, 01:31:41 AM...You could do a "DMM Adaptor" version which uses a DMM to display the readings. ....
The sweet thing about needle meters is you can do a LOT of math by marking the scale to suit. Division with a constant (which seems to be the objection to the simple plans) is just marking the scale 1 to 0. Multiplication, 100 to 0.
The really snazzy needle meters were the old SWR meters. The intersection of two needles, read on the middle lines 1 thru 8, does a division of two variables.
(http://i.postimg.cc/DZR9XbR3/pas-pm2000a-xl.jpg)
Quote from: BetterOffShred on October 08, 2021, 11:17:44 AM
This project is rad, do you think an ATTiny85 could do this?
That was the first one I had considered as an alternative. The ADC is 10 bit as well. I'd imagine if you have a stable 5 volts supply voltage it would be just as good if not better than the AIO arduinos with dodgy 5 volt references. I think I might have one or two kicking around I could try!
Could always use an external ADC. I was just looking at the MAX1241 (https://www.mouser.com/ProductDetail/Maxim-Integrated/MAX1241BCPA%2b?qs=1THa7WoU59EH%252B0%2FATToWhA%3D%3D). A little pricey though perhaps worth the accuracy if you're looking for precision here.
Quote from: Big Monk on October 08, 2021, 11:39:25 AM
This is my Lazy Man's Germanium tester:
https://www.amazon.com/Pocketable-Multifunctional-Backlight-Transistor-Capacitor/dp/B07X5YS1JN/ref=asc_df_B07X5YS1JN/?tag=hyprod-20&linkCode=df0&hvadid=416638923984&hvpos=&hvnetw=g&hvrand=4105942515975511802&hvpone=&hvptwo=&hvqmt=&hvdev=c&hvdvcmdl=&hvlocint=&hvlocphy=9005070&hvtargid=pla-845729973092&psc=1&tag=&ref=&adgrpid=93604202533&hvpone=&hvptwo=&hvadid=416638923984&hvpos=&hvnetw=g&hvrand=4105942515975511802&hvqmt=&hvdev=c&hvdvcmdl=&hvlocint=&hvlocphy=9005070&hvtargid=pla-845729973092
I've thought about grabbing one of those before. Does it display leakage as well? Has it been tested against other methods? Just curious.
Quote from: Kevin Mitchell on October 08, 2021, 01:01:37 PM
I've thought about grabbing one of those before. Does it display leakage as well? Has it been tested against other methods? Just curious.
Yes. It displays leakage with enough similarity to my R.G. Calcs that I have largely abandoned those.
In the end, I don't really want to know exact hFE and leakage values but merely ones close enough to allow me to rough sort and pick devices for circuits.
It's also much more convenient for testing ALL components than a meter.
QuoteThe sweet thing about needle meters is you can do a LOT of math by marking the scale to suit. Division with a constant (which seems to be the objection to the simple plans) is just marking the scale 1 to 0. Multiplication, 100 to 0.
The really snazzy needle meters were the old SWR meters. The intersection of two needles, read on the middle lines 1 thru 8, does a division of two variables.
Very very true. The scale can have a whole heap of evil tricks built in.
It's a total pain trying to emulate that stuff with analog electronics so a DMM display produces the right numbers (and also does it accurately). Even simple stuff like temperature measurements with thermocouples and RTD's have non-linearity which should be corrected (but is often not done in cheap DMM's ).
For modern stuff with microprocessors and LCD displays it's no problem doing the conversions.
Quote from: Kevin Mitchell on October 08, 2021, 01:01:37 PM
Quote from: BetterOffShred on October 08, 2021, 11:17:44 AM
This project is rad, do you think an ATTiny85 could do this?
That was the first one I had considered as an alternative. The ADC is 10 bit as well. I'd imagine if you have a stable 5 volts supply voltage it would be just as good if not better than the AIO arduinos with dodgy 5 volt references. I think I might have one or two kicking around I could try!
Could always use an external ADC. I was just looking at the MAX1241 (https://www.mouser.com/ProductDetail/Maxim-Integrated/MAX1241BCPA%2b?qs=1THa7WoU59EH%252B0%2FATToWhA%3D%3D). A little pricey though perhaps worth the accuracy if you're looking for precision here.
Quote from: Big Monk on October 08, 2021, 11:39:25 AM
This is my Lazy Man's Germanium tester:
https://www.amazon.com/Pocketable-Multifunctional-Backlight-Transistor-Capacitor/dp/B07X5YS1JN/ref=asc_df_B07X5YS1JN/?tag=hyprod-20&linkCode=df0&hvadid=416638923984&hvpos=&hvnetw=g&hvrand=4105942515975511802&hvpone=&hvptwo=&hvqmt=&hvdev=c&hvdvcmdl=&hvlocint=&hvlocphy=9005070&hvtargid=pla-845729973092&psc=1&tag=&ref=&adgrpid=93604202533&hvpone=&hvptwo=&hvadid=416638923984&hvpos=&hvnetw=g&hvrand=4105942515975511802&hvqmt=&hvdev=c&hvdvcmdl=&hvlocint=&hvlocphy=9005070&hvtargid=pla-845729973092
I've thought about grabbing one of those before. Does it display leakage as well? Has it been tested against other methods? Just curious.
I got a couple little attiny85 dev boards for a weather station I was fooling with, they have built in 5V regulators and a mini usb port for flashing them.
https://www.ebay.com/itm/Digispark-Kickstarter-ATTINY85-Micro-USB-Development-Board-for-Arduino-US-Stock-/191867257317?mkcid=16&mkevt=1&_trksid=p2349624.m46890.l49286&mkrid=711-127632-2357-0
I don't know much about programming them yet
And this thing ? $12.69 on Amazon.
(I do not promote this product)
(https://i.postimg.cc/jDYt9sGz/IMG-7560.jpg) (https://postimg.cc/jDYt9sGz)
While I could get the ATTINY85 to function for this purpose, as I played with it I had learned how non-linear the ADC behaves which is not ideal. But for basic purposes and for the transistor tester it works OK - depending on what grade of precision you're looking for.
Just pulled the trigger on a ADS1115 module from Adafruit (preassembled ADC circuit for these kinds of projects). It's 16bit so it'll scale 0.076mv per bit at 5 volts while the arduino's 10bit ADC could only do about 4mv per bit. Also snagged that TS12A4514P (SPST, N/O analog switch IC) - datasheet says logic control input is 2.6v so I could omit the buffer. Otherwise I would have replaced the 4049 with a simple opamp comparator to save breadboard real-estate.
So an update is coming soon 8)
Quote from: BetterOffShred on October 10, 2021, 11:25:28 AM
I don't know much about programming them yet
I use Arduino as ISP to burn bootloaders & program ATTINY or other Atmega chips that I use for proprietary projects.
Quote from: Phend on October 11, 2021, 11:18:34 AM
And this thing ? $12.69 on Amazon.
(I do not promote this product)
(https://i.postimg.cc/jDYt9sGz/IMG-7560.jpg) (https://postimg.cc/jDYt9sGz)
These did not measure leakage from my testing and always are way off from my Atlas DC55
Nice project Kevin. I did something similar myself with just a plain ATMega328P as the brains and an MCP4822 (12-bit ADC). I think I also have a unity-gain rail to rail op amp before the ADC powered by 5V, but it's been awhile since I looked at it. The whole thing is built into a 1590B with a transistor socket on top.
Since it doesn't really need to be a speedy process, my code is averaging a whole bunch of ADC measurements. It's probably overkill given the fluctuations GE transistors can have with temperature, but I don't see any harm in it either.
With regards to the other transistor testers people have linked, I'd be wary of those even if they do account for leakage. They often use very different test conditions than the RG Keen circuit (and often don't tell you what those conditions are). The RG Keen circuit tests at ~4uA base current if I remember correctly. I would guess that most generic transistor testers use a current that's quite a bit larger. Both readings would probably be "correct", but they can vary substantially. It depends on the transistor too. I have a DCA75 which is a great device, but its basic HFE measurement can be quite different from what you'd get using RG Keen's circuit - usually displaying a much higher HFE.
Quote from: Vorskla on October 12, 2021, 04:02:49 PM
Nice project Kevin. I did something similar myself with just a plain ATMega328P as the brains and an MCP4822 (12-bit ADC). I think I also have a unity-gain rail to rail op amp before the ADC powered by 5V, but it's been awhile since I looked at it. The whole thing is built into a 1590B with a transistor socket on top.
Without looking into it, I'm pretty sure the MCP4822 is a dual channel DAC - you pretty much just described my first CV controller design for modular synths - but it had an offset/multiplier post-DAC to scale for a 5 octave range.
Thanks for sharing your experience between the RG circuit and your DCA75. It's a given that the readings would vary as the test parameters aren't the same. As far as I understand, the RG circuit is ideal for Fuzz circuits while typical meters just give you some vanilla specs for general purpose. There's more to the story as I've found on the forum over the years and with recent searches. I feel RG is exhausted talking about it and probably gave a big eye roll to this thread ::)
Edit:
Your first post! Welcome to our DIY haven!
Seems to be boiling down to trust yours ears and not the quality control instruments.
Build a reference fuzz circuit, socket the transistors, and listen?
Quote from: Phend on October 12, 2021, 05:51:57 PM
Seems to be boiling down to trust yours ears and not the quality control instruments.
Build a reference fuzz circuit, socket the transistors, and listen?
Consistency, my friend.
If one supplies a fuzz pedal build kit with parts and does not want to disappoint (especially if an audio demo had been provided) it would be ideal to provide devices that have at least been spec'd and are close to the ones in the demo. Or if one is trying to replicate a certain signature fuzz pedal this would be an ideal tool to quickly sort through a lot of them for best matches.
Also, DIY tools for the bench are fun!
QuoteWithout looking into it, I'm pretty sure the MCP4822 is a dual channel DAC
Whoops! Thanks for the correction - I think it's probably an MCP3202. I use both series a decent amount and get them mixed up.
The RG circuit is definitely closer to the kind of currents fuzz circuits will typically see compared to a lot of generic testers out there and also compared to the test conditions used for the numbers in most (if not all) transistor datasheets. A test circuit like his or Kevin's has been a major time-saver for me. I do think it's worth giving an audio test to any set of GE transistors before building or at least socketing them, but using a tester beforehand can definitely weed out suboptimal ones and give you an idea of what values you personally like for which stage.
And yes, DIY tools are fun and I find the whole testing process kind of fun too in a weird way.
Quote from: PRR on October 07, 2021, 09:07:56 PM
What you really need is one of these. I doubt anybody will build it. Not enuff sexy mojo.
This looks too sexy hehe
BTW, when reading leakage wich one is the one that matters?
And about geofx gizmo and the TC-1 comparison, if you leave the transistor for 10 min seating quiet before reading the tests they are really close, at least in the ones I´ve tested so far.
Any updates on the simplified version??
Quote from: theehman on October 27, 2021, 03:25:17 PM
Any updates on the simplified version??
It really doesn't get much more simple after the initial post. You could replace the switching IC (CD4016 or CD4066) with a TS12A4514P. In doing so you'd be able to drop the buffer since the TS12A4514P can be triggered at a low threshold from the pulses provided by the Arduino directly.
To further simplify it you could drop the LCD display and use the Arduino IDE's serial monitor to relay the measurements - though it continuously scrolls.
I'll try to update the thread tonight with the latest design on the breadboard. New display, smaller switching IC, no buffer and using a nano instead of a mega :icon_lol:
Forgive me for what may be a dumb question, but does it do NPN as well?
Ahh didn't have time last night to draw a schematic. I have to clean up the code before I share though it's working wonderfully! Will do an A/B sample of the manual method VS my lazy man design to prove accuracy.
I might also draw up a PCB for a finalized version with all ICs + microcontroller on one board. I'd try to keep it DIY friendly but through-hole 16 bit DACs are pricey - may stick with the ADS1115 module.
Anyways, I'll try to update the thread with the accurate modular/breakout design over the weekend. Probably in an instructables style - it's a mess drawing schematics for modules.
Quote from: Ben N on October 28, 2021, 08:33:29 AM
Forgive me for what may be a dumb question, but does it do NPN as well?
Not as is, no. It would have to be modified to measure difference rather than the single point against ground. You'd also have to swap the power supply on the emitter & resistors. I'll further elaborate and add it to the final design!
Any updates on this??
Quote from: theehman on January 20, 2022, 12:36:43 PM
Any updates on this??
There certainly are some updates, just been busy with other things. I'll see if I have time over the weekend to dig into it again. Without getting into great detail right now, the design had taken a few turns as I tried to further simplify things while also using what I consider to be common parts in effort to ditch the breakout module. But that's moving further from being a Lazy Man's work :o
I'll be back with what I'll call the most simple design using the 10-bit ADC that most of these MCU's have. We'll call that Version 1.0, expanding from the proto in my first post. That way we can stick a fork in it as the finalized Lazy Man's Germanium Tester.
If anyone has thoughts on this feel free to put them up!
A little update.
I'm drawing a layout for an ATtiny85 version that uses 8 (4x2) segment displays. This is in effort to minimalize the design while using common parts & no breakout modules although you'll need means of an ISP programmer to burn the bootloader & firmware.
Update with breadboard proto & layout preview coming soon. I've got a few things on my bench right now but hope to get this situated during the week so I can get some boards fabricated.
To do;
-Implement a PNP/NPN switch
-Write a lookup table to easily write to 8 single-digit displays using shift registers
-Verify on breadboard
-Design PCB
-Circle back here to introduce the LMGT v1.0
Quote from: Kevin Mitchell on January 24, 2022, 12:12:17 PM
A little update.
I'm drawing a layout for an ATtiny85 version that uses 8 (4x2) segment displays. This is in effort to minimalize the design while using common parts & no breakout modules although you'll need means of an ISP programmer to burn the bootloader & firmware.
Update with breadboard proto & layout preview coming soon. I've got a few things on my bench right now but hope to get this situated during the week so I can get some boards fabricated.
To do;
-Implement a PNP/NPN switch
-Write a lookup table to easily write to 8 single-digit displays using shift registers
-Verify on breadboard
-Design PCB
-Circle back here to introduce the LMGT v1.0
Awesome!!
I think I have the PNP/NPN switching down. Sadly other than a DPDT switch this method also requires a bipolar supply as well as an inverting circuit and a buffer for good measure.
(https://i.postimg.cc/157MrPd7/TRANSISTOR-TESTER-IMG.png)
I could swing it a few different ways but the main implication is that the ADC's reading expects a positive voltage in respect to 0v ground. I'll sit on it for a bit but at the moment I can't think of a more efficient way to integrate both polarities within the same circuit.
Definitely open to suggestions.
Afterthought (more info on previous page) - I may have to double up some of the circuitry to avoid sending a negative polarity to the ADC due to user error. Or just be lazy and hope people read red labeled instructions :icon_lol:
Had a better idea. I've added another SPDT IC that is toggled by a comparator. So if the voltage from the buffer goes below 0v it trips the comparator which actuates the switch that determines the ADC's probe point - being pre-inverter or post-inverter. This means the measurement voltage will never go below 0v - depending on any offset characteristics of the chosen opamp. Even so, if the ADC does see below 0v it wouldn't be enough to damage the microcontroller.
https://tinyurl.com/yaa63t39
(https://i.postimg.cc/G2M3Y3CL/TRANSISTOR-TESTER-IMG.png)
From here I can drop the PNP/NPN polarity switch altogether and just use another device-under-test socket to accommodate the different devices - keeping this as simple as I can without risking any damaging user errors which would be a massive design flaw.
Quote from: Kevin Mitchell on January 26, 2022, 09:15:57 AM
This means the measurement voltage will never go below 0v - depending on any offset characteristics of the chosen opamp. Even so, if the ADC does see below 0v it wouldn't be enough to damage the microcontroller.
Why not just stick a Schottky in there for protection?
Quote from: Ben N on January 26, 2022, 09:37:40 AM
Why not just stick a Schottky in there for protection?
While that would add extra protection I fear it'll effect the measurement voltage. Besides, I believe there's protection diodes already in these microcontrollers - albeit, not as beefy.
Do you not like the automated routine? :icon_rolleyes:
That's not it, I just focused on what I could ponder with half a brain in the middle of my workday. ;D
Messed with it a little more for this neat circuit. Have at it.
https://tinyurl.com/y7kd26vn
I'm going to purchase some dual LED displays that will change color depending on what polarity device is being tested. Failure to insert a device properly should result in no display action (all LEDS off). I will be keeping the option to use normal less expensive displays with the same pinout - minus one anode pin. I still need to breadboard to verify - just waiting on the displays to arrive.
Power supply will be 9VAC, rectified to ~12v and converted down via adjustable regulators so we have a stable +/-9VDC supply.
So far with where the design is I literally have everything in my parts drawers minus the displays. All common parts though a long way from the simplicity of the OG circuit.
BOM so far (https://docs.google.com/spreadsheets/d/1V3LxidzAft8hUz2FGKpg41hjjI_gHr5oYZWQ62Sl6w4/edit?usp=sharing)
I also want to explore changing some of the Attiny85's pin configuration so I can free up the AREF pin. 5V resolution is not needed so if I can lower it while keeping it within the proper range I could improve the ADC resolution to monitor smaller voltage changes.
Quote from: Kevin Mitchell on October 06, 2021, 11:51:52 PM
I got lazy. And so can you!
I had breadboarded the germanium leakage and true gain tester from Geofex as I finally decided to order boxes of those recently popular new-old-stock Russian germanium transistors.
Because I absolutely hate math I had put together a spread sheet with the formulas ready to go! All I had to do was punch in the two measurements - open base voltage & closed base voltage.
Well apparently that was too much work for me and I got sick of it real quick. Numbers kept changing and results were slightly different each time I retyped the measurements
So the thought occurred to me early this afternoon, can I make an arduino do it? Turns out I can! And it's surprisingly accurate in comparison to the manual method.
Devices tested in this photo are MP39B - with noted gains between 20 & 60 according to our archives around the forum.
(https://i.postimg.cc/XnnZCQGz/20211006-230153.jpg)
Before I draw up a schematic I will say that the parts in the photo are certainly overkill as the majority of both ICs & Arduino are unused. I had also kept some uneeded values in the code just in case I wanted to display them to manually to check the results against a DMM & my pre-formulated spreadsheet.
Here's my code for anyone interested. I'll try to put up a schematic tomorrow, but it's rather straight forward. The number .00488 is to convert the resolution of the 10-bit ADC @ 5 volts to the actual voltage (5/1024 = ~0.00488).
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x3F, 16, 2);
int pulsePin = 55;
int adcPin = A0;
float voltageA;
float voltageB;
float voltageLeak;
float voltageGain;
void setup() {
lcd.begin();
lcd.backlight();
pinMode(pulsePin, OUTPUT);
}
void loop() {
//read open base
digitalWrite(pulsePin, LOW);
delay(50);
voltageA = analogRead(adcPin)*.00488;
//read closed base
digitalWrite(pulsePin, HIGH);
delay(50);
voltageB = analogRead(adcPin)*.00488;
//print result
voltageGain = (voltageB-voltageA)*100;
lcd.clear();
lcd.print("TGain = ");
lcd.print(voltageGain, 1);
lcd.print(" hfe");
voltageLeak = voltageA/2472*1000000;
lcd.setCursor(0, 1);
lcd.print("Leakage = ");
lcd.print(voltageLeak, 0);
lcd.print(" uA");
}
That's it for tonight 8)
dude.... DEWD!!! i think i love you!!! long time!!! outstanding!
Thanks for your kind words, Pinkjim! However a few months late to the party :P
The OP is a great resource for folks new programming with arduino. I was a bit rusty when I wrote it up but since then I've gotten better at writing efficient code. The final stand-alone version will be much more gratifying 8)
Hey, gang.
Good news! I've rewritten my code for the ATTiny85 chip and made a couple alterations to the circuit - now completely powered by 5v. The lower voltage ensures that the MCU's ADC does not see voltages outside of it's supply range and also allows for an easier approach for switching polarity for testing NPN devices via a 3pdt switch. It also means the buffer was no longer needed.
The following details the value choices, formulas and means of programming the ATTiny85 chip. I've included much detail to answer any predictable questions and also help anyone unfamiliar with programming AVR chips.
Math overview
Circuit values:
With selected values of 5V for VD and 1M for the base resistor (bRes);
If we want to see 1V per 100hfe we must select the collector resistor; cRes = 1 / ((VD / bRes) * hfePerVolt)
Which is; 1 / ((5 / 1000000) * 100) = 2000 ohms
Calculations for data:
NPN conversion: If the polarity switch is on (pin low), openBaseV = VD - openBaseV and closedBaseV = VD - closedBaseV
Gain = closedBaseV * hfePerVolt
Leakage µA = openBaseV / cRes * 1000000
True Gain = (closedBaseV - openBaseV) * hfePerVolt
Code:
// The Lazy Man's Germanium Tester V2.0 - for ATTINY85 and 2x16 I2C LCD
// By Kevin Mitchell for the DIY stompbox community
// Please review the schematic drawing for full circuit details
// This sketch was last updated on 8/25/2024
#include <TinyWireM.h> // I2C Master lib for ATTinys which use USI
#include <LiquidCrystal_attiny.h> // for LCD w/ GPIO MODIFIED for the ATtiny85
// setting up I2C
// SDA is pin 5
// SCL is pin 7
#define GPIO_ADDR 0x3F // the address of i2c for LCD
LiquidCrystal_I2C lcd(GPIO_ADDR, 16, 2); // set address & 16 chars / 2 lines
// define pins
#define adcPin A3 // pin 2
#define pulsePin PB4 // pin 3
#define polarityPin PB1 // pin 6
// define values
#define VD 5 // supply voltage
#define bRes 1000000 // base resistor value
#define hfePerVolt 100 // desired gain per volt to observe
#define cRes 2000 // collector resistor value, picked for 100hfe per volt: 1 / (VD / bRes) * hfePerVolt)
#define adcMult 0.0048828125 // multiplier to convert the ADC's 10-bit resolution to a voltage value: VD / (2^10)
float openBaseV;
float closedBaseV;
String polarityDisp;
// Custom display Characters
byte split[] = {
B01100,
B00110,
B01100,
B00110,
B01100,
B00110,
B01100,
B00110,
} ;
byte beta[] = {
B11110,
B10010,
B10100,
B10010,
B10001,
B10001,
B11110,
B10000
} ;
byte microAmp[] = {
B00000,
B00000,
B10001,
B10001,
B10001,
B10011,
B11101,
B10000
} ;
void setup() {
lcd.init();
lcd.noBacklight();
delay(100);
lcd.backlight();
lcd.clear();
lcd.createChar(0, split);
lcd.createChar(1, beta);
lcd.createChar(2, microAmp);
lcd.setCursor(1, 1);
lcd.write(1);
lcd.print("=");
lcd.setCursor(7, 0);
lcd.write(0);
lcd.setCursor(7, 1);
lcd.write(0);
// define digital pins - they are inputs by default
pinMode(PB4, OUTPUT);
pinMode(polarityPin, INPUT_PULLUP); // enable internal pullup for stabilization
}
void loop() {
// get open base voltage
digitalWrite(pulsePin, LOW);
delay(5);
openBaseV = analogRead(adcPin) * adcMult;
// get closed base voltage
digitalWrite(pulsePin, HIGH);
delay(5);
closedBaseV = analogRead(adcPin) * adcMult;
// polling the polarity switch status
if (digitalRead(polarityPin) == 1) {
polarityDisp = "PNP";
} else {
polarityDisp = "NPN";
openBaseV = VD - openBaseV;
closedBaseV = VD - closedBaseV;
}
// checking if a device is installed
if (openBaseV == 0 && closedBaseV == 0) {
lsPrint(8, 0, " TEST ");
lsPrint(8, 1, " READY ");
} else {
uint16_t leakage = openBaseV / cRes * 1000000;
uint16_t trueGain = (closedBaseV - openBaseV) * hfePerVolt;
rsPrint(13, 1, (String) trueGain);
rsPrint(13, 0, (String) leakage);
lsPrint(9, 0, "L=");
lcd.setCursor(14, 0);
lcd.write(2);
lcd.print("A");
lcd.setCursor(9, 1);
lcd.write(1);
lcd.print("=");
// display maintenance
if (leakage < 10) {
lcd.setCursor(12, 0);
lcd.print(" ");
}
if (trueGain < 10) {
lcd.setCursor(12, 1);
lcd.print(" ");
}
if (leakage < 100) {
lcd.setCursor(11, 0);
lcd.print(" ");
}
if (trueGain < 100) {
lcd.setCursor(11, 1);
lcd.print(" ");
}
lcd.setCursor(14, 1);
lcd.print(" ");
}
if (gain < 10) {
lcd.setCursor(4, 1);
lcd.print(" ");
}
if (gain < 100) {
lcd.setCursor(3, 1);
lcd.print(" ");
}
uint16_t gain = closedBaseV * hfePerVolt;
rsPrint(5, 1, (String) gain);
lsPrint(2, 0, polarityDisp);
delay(500); // slow the refresh/loop rate
}
// for printing strings from left to right
void lsPrint(uint8_t curX, uint8_t curY, String str) {
char charBuf[16];
str.toCharArray(charBuf, 16);
for (int ind = 0; ind < str.length(); ind++) {
lcd.setCursor(curX + ind, curY);
lcd.print(charBuf[ind]);
}
}
// for printing strings from right to left
void rsPrint(uint8_t curX, uint8_t curY, String str) {
char charBuf[16];
str.toCharArray(charBuf, 16);
for (int ind = 0; ind < str.length(); ind++) {
lcd.setCursor(curX - ind, curY);
lcd.print(charBuf[str.length() - (ind + 1)]);
}
}You may download the included libraries here (https://drive.google.com/drive/folders/1Hih4mu_q9eO2dHbclfdmFbVIEEPDXIVG?usp=sharing)
Know that the liquid display library may not work with all I2C drivers for a variety of reasons. After many trials the noted library is the only one that had worked for me.
This is the ATTiny85 core used for the bootloader - internal 8MHz is my preference. For arduino IDE on windows, copy the address to Arduino->File->Preferences and paste in "Additional Boards Manager URLs:" Then find & download it through Arduino->Tools->Board->Boards Manager.
https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/package_damellis_attiny_index.json
Here's the simplified schematic - no decoupling caps and the unused pins of the CD4066BE are floating. Just as the original, you may also use a CD4016BE.
Connections:
VCC is 9V and GNDD is 0V.
2x16 LCD with "I2C backpack" requires 5V, 0V, SCL & SDA. When programming the MCU make sure that the SCL and SDA pins are not installed.
ISP programming (I use Arduino as ISP or a USBTinyISP module) - requires 5V, 0V, MISO, MOSI, SCK and reset.
(https://i.postimg.cc/MpRP5NRK/LMGT-V2-0-PROTO-SCHEM.png)
Since I don't have any NPN germaniums on-hand to test I have the resistors to 0V, emmiter to 5V and the "polarityPin" floating. To test NPN, the polarityPin & emitter must be tied to 0V with the resistors to 5V. The code will account for the change so that it displays the specs appropriately.
Here's the breadboard preview while testing a few different PNP germanium transistor.
No DUT
(https://i.postimg.cc/fkvhq3nv/20240824-191431.jpg) (https://postimg.cc/fkvhq3nv)
OC76
(https://i.postimg.cc/ZWWtqV9f/20240824-191422.jpg) (https://postimg.cc/ZWWtqV9f)
1T308B (1T308V)
(https://i.postimg.cc/rd4B1sNx/20240824-191723.jpg) (https://postimg.cc/rd4B1sNx)
МП39Б (MP39B)
(https://i.postimg.cc/k2LrRKK7/20240824-192140.jpg) (https://postimg.cc/k2LrRKK7)
I think you're ready to build your own Peak Atlas (https://www.peakelec.co.uk/acatalog/dca55-atlas-dca-semiconductor-analyser.html)!
Quote from: ElectricDruid on August 25, 2024, 01:29:49 PMI think you're ready to build your own Peak Atlas (https://www.peakelec.co.uk/acatalog/dca55-atlas-dca-semiconductor-analyser.html)!
That's actually a bit of inspiration on this take - but over $100 less expensive :icon_rolleyes:. I'm going to 3D print a custom case and have a set of 3 test hook clips that plug in via a stereo jack.
Previous post updated with code & libraries.
Today I accidentally acquired (I took them from where they were lying around as unnecessary) two old Soviet germanium transistors. P5V, manufactured in 1963. They were just lying in a closet with obsolete electronic parts at a friend's. Who is not interested in them and got them from another person.
Surprisingly, the transistor tester showed their gain factor for one of them as 216, and for the other 311 (!!) Although according to technical characteristics, their standard figure is 32-200.
I suppose that some electronics engineer once, in the 70s, saved them for himself as unique, and then they lay in boxes for about 50 years. And now I can make a real, authentic germanium fuzz out of them))
They look like this:
(https://lh4.googleusercontent.com/proxy/ThY9Bq6cF8FDsGVOnk4E8WClXPEIRYmD7Fsjk7PmNZWsNiC7wxvg7MOCZMeVSvXbPnvMWF9k3OA)
Nice! I have yet to come across a germ with such high gain.
For example, I have 100 MP39B which have published gains of 20 to 60, albeit likely before leakage deduction.
Out of the whole lot I only have one with ~35 true gain, and a few just under while the rest were in the low 20s.
Even in a gold mine it's a miracle to find a nugget.
Lot of Russian germanium transistors gain spec (on the sheets) is at a higher current. Most tested how we test them are usually at the lower end of the spec.
Quote from: mozz on September 09, 2024, 04:04:10 PMLot of Russian germanium transistors gain spec (on the sheets) is at a higher current. Most tested how we test them are usually at the lower end of the spec.
Ah yes, a very valid point. The downside is the specs I'm mentioning were on a listing for fuzz transistors - kind of misleading if one didn't know any better.
A week or so ago I was looking at a listing for soviet germs and they claimed to had used an incredibly expensive and dated transistor tester - printed results on receipt paper.
And I'm over here shooting 5 microamps into the base hoping to contrasts.
So, for our 9v effects it's best to assume the lower range then :icon_wink:
But of course, a regular digital transistor tester, as they say, does not show the real gain of germanium transistors. And it is necessary to check the gain in a special way, described in the article on selecting transistors for fuzz face
https://i.ibb.co/cw6fvq4/image.png
(https://i.ibb.co/cw6fvq4/image.png)
That's real gain, but more importantly 1330ua of leakage.
Yesterday I tried to comprehend the arithmetic and calculations of the article on selecting transistors for FF, but it seems my old brain is no longer enough to understand such calculations ((
here is this article:http://www.geofex.com/article_folders/ffselect.htm#:~:text=To%20test%20the%20total%20gain,and%20the%20amplified%20base%20current. (http://www.geofex.com/article_folders/ffselect.htm#:~:text=To%20test%20the%20total%20gain,and%20the%20amplified%20base%20current.)
Maybe someone has a link to an article with a different explanation? With a different approach? Which might be within my power?
Recently I assembled a circuit that helps to accurately determine the cutoff current in a field-effect transistor. To select suitable specimens. I was able to do this)) I had enough intelligence for this. But germanium transistors(...
Of the devices, I have a modern transistor tester, a digital multimeter, a pointer multimeter (not very accurate anymore), a frequency meter.
Ohms law is all you really need. I've included a breakdown of the formulas used in my last update.
There isn't much explanation on the math behind the value choices in the article.
The explanation that I would like to see is how the suggested collector resistor value of 2.472K was figured. I believe it's derived from the ballpark value of typical conductance of germanium devices which was briefly mentioned - where it's noted that the real base current is 4.046uA while the math without such consideration is 9 / 2,200,000 = ~4.091uA. This vague value is not considered within my math. Without such consideration the collector resistor would be ~2.444K according to my breakdown. I'm sure the difference would be considered negligible for our purpose - we are not to expect perfect results in either case, only reasonable estimates.
Edit: I'll cover it again. You can modify values to fit your situation.
Punching these formulas in an excel sheet will make it much easier for you - or just build my tester ;)
These values are predetermined and are of my own choice - you can make these whatever you'd like or rather, measure your parts & supply as best you can and adjust the values within the formulas.
VD = 5.00V
Base Resistor = 1M
Resolution target is 1V per 100hfe.
We need to find out how much current the base is getting with the 1M resistor connected.
5 / 1,000,000 = 0.000005 which is equal to 5 microamps
Then we use that to figure our collector resistor for 1V per 100hfe results
1 / (0.000005 * 100) = 2,000 which is how I got a 2K resistor using my selected values.
From here we use the formulas provided in the article - as follows.
For general gain we close the base resistor, measure around the collector resistor and multiply by our predetermined resolution target.
So if it reads say 1.286V, that's 1.286 * 100 = 128.6hfe
But we want true gain, so we take a measurement while the base resistor is not connected for leakage.
With the base open, let's say the voltage around the collector resistor is 0.186V - that's leakage in volts. For leakage current we divide by the resistor value.
0.186 / 2000 = 0.000093 Amps, or 93uA
For true gain, simply subtract the open voltage measurement from the closed voltage measurement and multiply by our target resolution
(1.286 - 0.186) * 100 = 110hfe
I found out that a friend has an old pointer device (I think it's a factory one) for checking old transistors (he says that you can even connect headphones there to listen to the gain) and I'm thinking of contacting him to check my germanium transistors. But, I have two more questions for the manufacturers of germanium fuses.
1 - Does it happen that even those precisely selected using a special device and these unpleasant formulas)) need to be selected by ear? To choose from them, the best-sounding germanium transistors? Like those of the famous rock bands of the 70s?
And is it possible to select transistors using a digital transistor, and then by selection, plugging different copies into the transistor connectors on the board?
2 - And are there any samples of the best germanium fuse on the Internet? Sounding recognizably like the 60-70s?
(I've listened to a lot of fuzz faces and the like on YouTube, but it's not always the sound of that old, recognizable 60-70s specificity. Often it's just fuzz. Average. Something in between, germanium-silicon, general dispersion.
And Germanium fuzz, for me personally, is: itchy, flat, with a predominance of a narrow band of high-mid frequencies, with a click in the attack. As if the sound is passing through a lock, through a damper, through an edge, through an obstacle.)
I've seen old tube testers have a headphone jack, to test for noise. I think a simple circuit like a range master would suffice. They (Hickok,HP, Fluke) used to make semiconductor analyzers but they still want a good buck for used ones. I'm tempted to make one to measure noise with output hooked up to a wideband level meter, scope and headphones. Usually the noisiest are high gain with high leakage, but not always.
In attempts to master the correct measurement of the gain of germanium transistors, I encountered very nasty, some mystical problems. "Resistance of the material." Nervously!)) At first, everything went according to the rules, as written. And then a dead end. Perhaps my digital multimeter broke (I need to check it tomorrow). And I tried to measure the current on an arrow device, but I noticed that the transistor under study began to heat up! And I gave up for now. But, I wanted to ask questions:
1-Tell me, the general opinion is that digital transistor testers are not accurate in measuring germanium, because they do not take into account the leakage current. But I also read that they take this leakage current into account! Please explain, do they take it into account or not? Or does it depend on different models? My transistor tester is already old and I do not remember the model, I do not know the firmware, but based on this data, what can I assume?
(https://i.imgur.com/1hxd5OQ.jpeg)
2- I read experts who claim that fuzz-faces need transistors without a large leakage current, but for Tone Bender-s, on the contrary, with "leaky" transistors. Do you agree? And so almost any transistors are suitable, the main thing is the gain factor of OT 60-70?
These low voltage tests are good enough for our purpose.
Mozz was implying that ICEO is leakage on your tool. Look up ICEO.
Not to disappoint, but I would encourage you to create another thread to inquire on other questions unrelated to the topic at-hand (my tester). Other than my not being able to answer some of your questions, you'll get better guidance with the bonus of not derailing things here.
Kevin Mitchell, I already understand that I have begun to overload your topic with third-party data. Sorry. Thank you for your patience))
+
And thank you for the useful topic.
(my problem with the multimeter has cleared up (the fuse burned out) and I can use the classic method of calculating the gain again and I will try not to overload this topic with my deviations from the main direction)
-