I'm posting this here because I do not know where else to put this.
After a recent discussion with JM Fahey about JFET variations, I started thinking about a test rig idea I came up with a while back. Here is a schematic showing my idea next to a much simpler test rig similar to the one shown on the Fetzer valve page at ROG and, I believe, similar to one JM posted:
(http://www.riemer.us/jfet-test-rig/JFETTestRigSchematic.jpg)
With the simple rig on the left with the switch positioned as shown, the absolute value of the JFET's threshold voltage will be shown on the multimeter. In the other position, the 1 Mohm R1 is shunted, and you divide the voltage shown on the Multimeter by the 100 ohm value of R2 to get the IDss.
My rig is shown on the right. U3 (multisim wants to label these as Ux since these parts are not in there master database) enables or disables the test rig according to its gate voltage. U5 is used for shunting R3 to switch between test modes. I added a couple of LEDs to indicate the test mode. The two MOSFETs in each LED setup work as an AND gate. The gate of the top MOSFET in each setup recieves the same enable signal as U3. The bottom MOSFET of the first LED setup recieves the same ON signal as U5. The bottom MOSFET of the second setup recieves an ON signal when the first setup is off.
At first glance, it may seem like I am working on a Rube Goldberg type JFET test rig. After all, this isn't any easier to use than the simpler version, it requires more parts, and the LED indicators are kinda just eye candy. But imagine if you replace the mechanical switches labeled J2 and J3 with the digital outputs of an Arduino board or some other similar board. Then, instead of a multimeter, use an analog input of the Arduino for measurement. Maybe add a button for one of the Arduino digital inputs to tell it when to take the measurements. Then, you simply pop in a jfet, hit a button, and the arduino takes both measurements in an instant. You might not even need the button to tell the Arduino when to take the measurement. You could have an optical switch that is interupted when a JFET is placed in the socket to trigger the measurements. You could write an application to take the Arduino output and automatically populate a spreadsheet or database with your measurements. Then, measuring a bag of JFETs can be done much more quickly.
Take this a step further. Set up a reel feeder to run a reel of JFETs through the tester. Advance the reel one JFET at a time using an optical switch to determine when a JFET is in position. Have a three prong probe or socket move up to engage the pins of the JFET. Then take the measurements. Then advance to the next JFET. Write an application that generates a unique identifier for the reel and print a label with that identifier to put on the reel when you are done measuring. When each measurement is taken, have your application on your PC record the unique identifier, the offset of the JFET from the beginning of the reel, and the JFET's measurements stored in a database. You can then very quickly catalog a whole reel of JFETs.
Tonight, I breadboarded the simple rig and measured several JFETs and recorded them to use for comparison. I then built my rig and demonstrated that it worked. Tomorrow, I'll take measurements of the same JFETs. Then, if I have time, I'll try to get it working with my Arduino. I'll post more stuff later.
Here's a quick demo video of my breadboarded rig. http://www.youtube.com/watch?v=unzQ3NeTnkE (http://www.youtube.com/watch?v=unzQ3NeTnkE)
I hooked this rig up to my Arduino tonight. When I did my testing yesterday, I forgot Arduino has 5V digital outputs. Initially, using the Arduino to enable the test rig, cut off voltages were a bit low. I used an LM324 comparator to bump up the 5 volt Arduino outputs to 12V. This seemed to work much better.
My arduino program (sketch in Arduino terminology) enables the test rig, makes sure the mode output is low, measures the cutoff, sets the mode output high, measures Idss, and then sets the enable output low. It writes the results to the serial port (well, ftdi chip connected to the PC via usb connection). The measurements are slightly lower than with the multimeter and standard measurement rig. I don't know which is more accurate. I bought my multimeter from a flea market years ago, so I don't have a lot of faith in it. :) In any case, I imagine the measurements are close enough.
Here's a demo with the arduino added to the test rig. http://www.youtube.com/watch?v=OVMhmgWExIo (http://www.youtube.com/watch?v=OVMhmgWExIo)
I'll try to remember to post the source code later.
I don't know enough about testing FETs (never even done it before) to know why this is better than the more simple version that most folks use. But I will say one thing, NEAT!
Well, it's eventually supposed to be a means for measuring them more quickly. It might only eliminate a few steps, but if you have a few hundred JFETs to measure, eliminating a few steps can make a big difference. Also, suppose you are mass producing amplifiers and you want to use JFETs in your design. If you have a test rig with a reel feeder, you can send a whole reel of these through, and quickly find the ones whose characteristics are in the range deemed acceptable for your design.
Obviously, with my bread board setup, it's not very fast. This is mainly because I have to pay close attention to where I place each JFET on the breadboard. Also, I don't have a spare momentary switch button set up yet to trigger the test, so I have to type in 't' in the serial port monitor on my lap top, and click the send button. But I can through this design on some perf board, put that in an enclosure, and have a box with a button and a socket for the JFET. And, of course, a way to connect the arduino board. Then, it is as simple as inserting the JFET into the socket and pressing the button. The lights will indicate when the test is complete. Then pop in the next one. The output from the arduino has all the measurements, so as long as I keep the JFETs in order, I don't even have to write the measurements down. I don't have to worry about screwing up dividing the voltage by 100 for the Idss test. Of course, that's simple math, but when you're measuring a whole bag of JFETs, brain-fart mistakes happen.
I think I might can even eliminate the pressing-the-button-to-start step. I bet, in between tests, I can check for a voltage on the analog input of the arduino, and trigger a test when it reads a voltage. I can adjust the trigger code to only trigger if there is a voltage for a few thousand samples to eliminate false triggers from interference on the analog input.
IM-PRES-SIVE.
Congratulations.
And remember Rube Goldberg's contraptions were funny but *did* work, he was a brilliant engineer after all.
*Why* Fet manufacturers don't offer this service is beyond me.
As you say, they might offer a 5000 FET roll, with a spreadsheet (actually, a simple table) in a cheap CD accompanying said roll.
Oh well.
The Japanese at least colour code their transistors, besides the "official" part number.
Congratulations again.
Thanks, JM. And thanks Joe Cool (fogot to thank him earlier for saying this project was neat).
Quote from: J M Fahey on February 25, 2011, 10:28:57 AM
...
*Why* Fet manufacturers don't offer this service is beyond me.
...
This is something vendors like Small Bear could do, since their customers are primarily builders of stomp boxes and amps. They might could sort JFETs into groups by narrow criteria and tack on a few more cents on the price. I think I would pay an extra 20 or 30 cents per JFET if I knew what I was getting rather than order a few hundred and have to measure them to find the few that I want to use.
Ah, this whole projects makes much more sense to me now. Thanks for taking the time to explain it out. You should offer the schematic to Steve at SmallBear, with an easy to use interface like this maybe he would consider pretesting the FETs as you have suggested.
I sent an email earlier to the email address listed on their main page suggesting that they offer such a service regardless of what testing rig design they come up with. I included a link to this thread. Mine is certainly simple and certainly not complete enough to start feeding reels of JFETs through. But they are certainly welcome to use as much of my design as they want.
Someone requested the source code I used for this project, and I figured this would be a good place to post it, so here it is:
#define TEST_RIG_ENABLE_PIN 4
#define TEST_MODE_PIN 3
#define MEASUREMENT_PIN 0
#define CONVERSION_FACTOR 0.97
void setup()
{
pinMode(TEST_RIG_ENABLE_PIN, OUTPUT);
pinMode(TEST_MODE_PIN, OUTPUT);
digitalWrite(TEST_RIG_ENABLE_PIN, HIGH);
Serial.begin(9600);
Serial.write("Initialized\n");
}
void loop()
{
if(Serial.available() > 0)
{
int input = Serial.read();
//if(input == 't')
//{
performTest();
//}
}
}
void performTest()
{
digitalWrite(TEST_RIG_ENABLE_PIN, LOW);
Serial.write("Performing Test\n");
float Vpp = getVpp();
Serial.write("Vpp = ");
Serial.print(Vpp);
Serial.write(" V\n");
float Idss = getIdss();
Serial.write("Idss = ");
Serial.print(Idss * 1000);
Serial.write(" mA\n");
digitalWrite(TEST_RIG_ENABLE_PIN, HIGH);
Serial.write("Test Complete\n");
}
float getVpp()
{
digitalWrite(TEST_MODE_PIN, HIGH);
float value = 0;
float accumulatedValue = 0;
int numberOfSamples = 10000;
for(int iteration = 0; iteration < numberOfSamples; ++iteration)
accumulatedValue += analogRead(MEASUREMENT_PIN);
value = accumulatedValue/numberOfSamples;
value = value/-1024 * 5 * CONVERSION_FACTOR;
return(value);
}
float getIdss()
{
digitalWrite(TEST_MODE_PIN, LOW);
float value = 0;
float accumulatedValue = 0;
int numberOfSamples = 10000;
for(int iteration = 0; iteration < numberOfSamples; ++iteration)
accumulatedValue += analogRead(MEASUREMENT_PIN);
value = accumulatedValue/numberOfSamples;
value = value/1024 * .05 * CONVERSION_FACTOR;
return(value);
}
:dbtu: :dbtu: :dbtu: :cheesy:
So.. I have to ask... rowdy_r, are you involved with any company that needs a lot of super-sorted JFETS for use in amplifiers?
Hehehe, nope. I'm just a tinkerer. I do have an AAS in Computer Integrated Manufacturing, which no doubt shaped some of my thinking here, but I've been simply writing software, mostly in C++, for most of the career. I figured this sort of thing could be useful. I wish I had the time to see this project all the way through, even if it's just for fun.
BTW, has anyone considered making their own JFET's? I've been thinking about the possibility of making a JFET with an aluminum-doped zinc-oxide channel and a copper II oxide gate. My choice of materials are simply based on the fact that making zinc oxide and copper II oxide at home is probably easier than making your own silicon JFET's. I did see a video somewhere where some very intelligent woman made her own MOSFET at home, though she did have some equipment that one wouldn't normally find at home.
I'd first probably see if I could produce a small rod of zinc chloride. I saw some documentation where powdered zinc oxide was packed into a... I think a rod... and then sintered at 600 degrees C. I read somewhere else where a bit of aluminum chloride can be used to boost conductivity. If I could succeed at producing a conductive zinc-oxide rod, then, I would work out how to bond aluminum oxide to it for a gate. If I could ever get to that point, maybe I would play with channel and gate geometries, doping, etc. to see what I could get.
BTW, Thanks, JM!
Darn... I was hoping there was a new JFET guitar (pre)amp about to be released by some company.
Sounds like you are taking the homemade electronics to a new level with EZ-bake jfets! 8)
Hehehe, we'll see if I actually get to follow up on that idea. I like your name for that concept, btw!
Well, it must be physically possible.
The first (1948) transistor was made by Bardeen and Brattain at Bell Labs "by hand", working on a desktop .
In fact, they were trying to make a FET !!!
Then they discovered that their "FET" had more gain than expected.
Since the Scientific mind tries to understand every "error", instead of sweeping it under the rug, what they found was the bipolar effect, so our bipolar transistors. 8)
As a side note, I once visited a Chinese Electronics Expo in Buenos Aires, in the 70's , *before* USA stuffed them with Technology and $$$$$$$$$$$ , and talked to some of the cool guys (and gals) there.
They were from some University, were proudly showing their self made oscilloscopes, and when asked about parts availability, they said they made their own transistors at the University. :o :loco :duh
How's that ??? :dbtu: :dbtu:
an interseting project;one that could be done using BASCOM AVR (free BASIC compiler for the AVR microcontrollers) for the arduino-phobic :-\
"and when asked about parts availability, they said they made their own transistors at the University. " Excellent!!