CategoryElectronics

µC Prototype JFET Vp/Idss Tester Part 5: Designing a slightly better tester

So I decided a few things since etching the last PCB:

  1. I’d design a new board that used a high quality ADC (16+ bits), preferably Sigma-Delta and not SAR
  2. Since the ADC was on the board, may as well throw an AVR on there too!
  3. SMT was necessary
  4. Some type of USB connectivity was necessary (RS-232 wouldn’t be so bad since I have plenty of RS-232<->USB adapter cables for my networking stuff)

So I came up with my board layouts (I should really do schematics first, very bad practice), and it looked pretty good. I tried to etch it and each side came out fine, but I was about 0.004″ off on my alignment which made my vias unusable. Also I couldn’t do a via for through-hole stuff (but I could solder each side). I quickly decided I was going to have boards printed up.

In design I chose an ATTiny1634 as it was fairly small and had more than 512b of RAM.

I use ExpressPCB. It’s pretty lame, but it was doing the job for me with single sided stuff.. and I’m used to it, I’ve done layouts in it before although I’ve never etched a board from those layouts until recently. They offer a proto-board service at 3 boards for $59 with exactly 3.8″x2.5″ dimensions. That’s just over $6 per square inch, which isn’t bad — but then they don’t include soldermasks or silkscreens and they charge you like $25 to ship the things. I found some software that could actually read ExpressPCB files so I didn’t have to do my layout over again and could work with a simple tool in familiarity (even if I loathe it). It’s called Copper Connection and has a free version which properly translates the printed images (ExpressPCB does not) so you could theoretically do double sided boards — and your single side bottoms don’t come out flipped. Oh hey, it’s picture time so you don’t get too bored!

JFET 7.0.8-BOTTOM

JFET 7.0.8-BOTTOM

As you can see, the bottom transfer failed in one spot, but it’s not critical. The small traces all came out great, and it looks kind of pretty.

JFET 7.0.8-TOP

JFET 7.0.8-TOP

 

It can ALSO export Gerbers if you pay for it, perfect! It even has some settings for OSHPark exports, among a couple other PCB houses. OSHPark does 3 boards @ $5/in^2 of your board dimensions and a more reasonable ~$5 in shipping. So I paid under $46 for 3 boards. Score. I also paid for the most expensive version of Copper Connection so I could have the freely readable text version which can be stored along with the code in Git.

I know I wrote a wall of text. I apologize! But I digress.. getting back to the board, it was pretty great. It was going to be awesome to do things this way. I ordered a USB to TTL cable with an FTDI chip in it so I just had to bring out the USART pins and grab power from USB.

I used one of my LTC2439 chips (pin compatible with LTC2418), which is 16 bit.. just in case there was something wrong with the board layout. And god was there. But it looked a hell of a lot better than my etches, everything lined up, it had vias, a soldermask, a silk screen (where I didn’t bother with component labeling), and I made a few revisions to the board before it went out:

JFET 7.0.8a-BOTTOM

JFET 7.0.8a-BOTTOM

As you can see I have a few components already soldered — and there’s a solder bridge. You’ll find out why after the next picture which has the towering totally uncalled for MOSFET and some headers in. This is my first attempt at SMD soldering, so don’t be too harsh!

JFET 7.0.8a-TOP

JFET 7.0.8a-TOP

Total board errata (I did some of the tracing late at night..):

  • ATTiny1634 is SOIC-20, board has SOIC-24!
  • ICSP header holes are too small (drill size)
  • FTDI header holes are too small (drill size)
  • J1 AREF holes are too small (drill size)
  • Increase distance between resistors and JFET receptacles
  • MOSFET Silk is reversed
  • MOSFET Drain grounded — WTF?
  • No decoupling caps are on the uC/ADC
  • Minor trace issues to ADC (not lining up perfectly — clearance could be increased)
  • Missing pull-up resistor for !CS on ADC
  • MOSFET for Idss/Vp mode (SOT23-6) incorrect (pins 5/6 swapped & connected to G instead of S on DUT)

 

Some of these were easily overcome. The SOIC-24 pads I was able to just bridge the last few pins since I used very few pins on the ATTiny1634 as I counted pins from each end of the chip, so I just laid it down where most of the pins already lined up.

The incorrectly sized vias for through-hole stuff was rectified with a dremel and a sanding drum so I could get my headers on the board. The MOSFET that the uC was going to switch was just a complete disaster, I had to cut traces with a razor and just let the uC directly switch the MOSFET on each JFET.

No decoupling caps is pretty much inexcusable, but doesn’t seem to be an issue thus far. My Fluke 175 agrees with the ADC insofar as the resolution that the Fluke has.

The missing pull up resistor was a problem as I was using the same SPI lines that ICSP (In Circuit System Programming) uses, the second I soldered the ADC on (which being TSSOP-28 you’d think would be the hardest chip on the board.. nope, easily the easiest) I could no longer program the ATTiny. So I soldered a resistor right on top of the chip between Vdd and the uC pin connected to !CS on the ADC. With !CS being (weakly) high during reset, the ADC no longer interfered with programming the device.

Ultimately I didn’t like the way the USI module of the ATTiny did SPI so I just decided to bit bang it anyway, making all of these issues moot as in the future I can just connect it to any pins I want.

Speaking of, you know how I did a poor job of soldering SMD before? Here’s where I makeup for that with perfect alignment and a good solder finish. 0.5mm pitch is fun!

TSSOP Soldering Up Close

TSSOP Soldering Up Close

I also should’ve put some LEDs on the board to use as status indicators, and pulled up spare IO pins onto a header.

Nearly un-correctable errata: The SOT23-6 MOSFET (I’m just using the N-side for now, it’s an N/P pair) was traced to the JFET completely incorrectly making it useless, I can’t measure Vp and Idss since it can’t switch what it needs to. I might overcome this before the next board revision/print by cutting the traces and wiring the Source and Drain where they need to go, but that’s a huge pain and I kind of just want new boards.

In the future I’m going to keep the uC board separate from the JFET/ADC board, for the next couple of revisions I’m keeping the same basic hardware layout, correcting errata and cleaning up the layout a bit.

And finally.. here’s the semi-functional board with the ICSP and USB cable hooked up and actually reading Vp for each JFET (the MOSFET is actually removed now, traces cut, and a solder bridge is there between two of the vias)

JFET-7.0.8a-Partially Assembled-Top

JFET-7.0.8a-Partially Assembled-Top

Code is up on GitHub for all to see. Make your own, I dare you.. because it’s totally not worth it unless you’re really into JFETs or you’re a masochist.  I actually might make the ADC board card-edge and have a base board with the uC, hmm!

µC Prototype JFET Vpp/Idss Tester Part 4: 20 JFETs, 10 TL072s and a bunch of drilling later..

So after the previous failure with using a lower value sense resistor (which was probably not the real issue), I decided to keep the 100 ohm resistor in place and just buffer the reading with an opamp. I tested it on a breadboard first to empirically verify it wasn’t a really dumb idea.

I mean, it may be a really dumb idea, but it worked as I hoped.

Here you can see the top of the board with poorly drilled holes and a mash-pot of resistors. It’s a prototype and my Mouser order that included an assortment of 1% metal film resistors didn’t arrive yet, so I used what I had available. When I ran out of carbon film 5% I used what was left of the metal films. I even had to resort to 1/8 watt resistors on the attentuator following the opamp. The header has expanded to 8 pins so you can either monitor the original voltage or half voltage. At the least one resistor in the attenuator should be socketed or a trim pot. Ideally we’d be able to measure the value of the resistor network or the trim pot from the micro itself, but that adds a lot of complexity — but perhaps a 4:1 muxer for each ADC would be in order, along with detection for over-voltage before the attenuator so we can just sample the before that.. then we could actually add gain to the opamp instead of operating at unity to measure low Idss/Vpp devices more accurately.

 

JFET Tester with TL072 Buffer (Ironically with JFETs!)

JFET Tester with TL072 Buffer (Ironically with JFETs!)

Wouldn’t it be nice if I had real 2×4 headers, cables to plug into them, and better sockets for the JFETs? Ah well, it will do for now! I have yet to test it, I’m working on a new board design with relays (or maybe a muxer with low On resistance), the microcontroller and extra ADCs on board.. Of course that means I’ll need a way to create 2 layer boards of higher quality than what I’ve been producing.. and vias.. oh fun.

Updates to come!

µC Prototype JFET Vpp/Idss Tester — scalable to 20-50+ at a time Phase 3: The 8 Little JFETs That Could, my Second Etched PCB And FAILURE!

So I decided to setup a new PCB with 3 pins to connect to, otherwise I had to hook the ADCs into the relays. Now they can have their own run straight to the board, and the relays can have their NO or NC contact hooked up to the same trace. The JFET gate is COM. This was a pretty good improvement although I didn’t really have female 0.1″ pitch headers — I had some cheap 6 pin “Arduino” headers that are NOT the breakable kind. That left me with a few 2 pin headers until I wised up and heated a razor up with a propane torch in order to split them.

One 3 pin header holds the JFET (rather loosely in these, unfortunately) while the other 3 pin is for the relay/ADC connections viagra ohne rezept aus deutschland. If you look closely you’ll note the toner transfer wasn’t perfect and my freehand quick drilling job is even less so, but I knew this was a prototype and I wasn’t too concerned with it so long as I had enough copper to solder to. I’ll probably try a smaller bit next time and I’ll fill the pads in completely.

I switched from an Arduino Due to an AtMega2560 board since they had them for $10 at MicroCenter. It actually has a 16 channel muxer to the ADC so I can measure 16 JFETs at a time without adding any ADCs. I did order some ADCs as samples, hopefully they’ll be approved and sent to me so I get some freebies. I went with mostly surface mount so I can do a two layer PCB and leave the ADC signal traces on top, I did a couple quick designs of such a PCB and it wound up being extremely easy to get what looks like good routing to me.

The board supports 2 rows of 9, I left an extra one in each row for redundancy in case I had bad traces on any of the cells. Fortunately they all turned out fine. You’ll also note I only filled in one row, as I figured I’d run into a bit of a problem testing the 2N5638 JFETs which can exceed a 50ma Idss and thus exceed 5.0v

 

Arduiino JFET Tester 16

Arduiino JFET Tester Mini-x16 v1.0 (3×5 PCB)

So I decided to change the sense resistor from 100Ω to 47Ω and did some minor revamping of the Arduino sketch. The program is still pretty poor, but it does its job for the time being. I ran out of 1MΩ resistors so I used 10MΩ, which shouldn’t affect Idss or Vpp readings. Unfortunately it seems like going with the 47/10M combo causes some serious heat in the devices. Almost immediately after I hooked power up (12V) I smelled hot plastic. My initial thought was that I got the polarity incorrect and I even feared that I might have blown the muxer or ADC in the AVR chip.

Now I’m really not that familiar with transistors at all, nevermind JFETs (this is a learning experience for me), but I’m assuming I’m getting too much voltage with the 47Ω sense resistor in place. I didn’t want to use a straight voltage divider, I may have to go back to 100Ω and use a JFET or op-amp buffer with an attenuator after it.

The measurements on the other hand seemed OK (I had 2SK170s in every other socket), but I shouldn’t be nearly melting devices or measuring with die/case temperatures anywhere near that high. Touching one of the devices extremely briefly nearly gave me a burn, at which point I immediately pulled the power.

At this point I’m going to consider my options and re-design, a TL072 (has a JFET LTP on the input, so very high input impedance) might be smaller than TO92 JFETs for a buffer, and would certainly be linear. I’m not sure I want to use any SMD stuff, and I really don’t want to deal with making vias in prototype PCBs.

 

Update: Also the 1M resistors that were supposed to be in place were apparently 1K. Apparently I’m awesome at reading DMMs and color bands. I redesigned the board for an opamp buffer before discovering that.

µC Prototype JFET Vpp/Idss Tester — scalable to 20-50+ at a time Phase 2: The 12 Little JFETs That Could and my First Etched PCB

I’ve been experimenting with making PCBs. I’ve always wanted to, but it’s something that I’ve never actually had the chance to do. I went through many a lot of iterations trying to get the toner transfer method to work.

In retrospect my big mistake was grabbing Kodak’s Ultra High Quality inkjet glossy photo paper. Photo paper can work well, but not this 10.7mm thick stuff with a plastic back. I didn’t actually have an iron, so I tried everything I could think of and only wound up going from almost no toner transfer to getting around 80% of the toner transferred with lots of broken traces. I started with a ‘hobby iron,’ which didn’t have enough contact area or enough heat. I was going to use a hobby heat gun, but I couldn’t locate it. I went through probably around 20 sheets of the stuff. I tried heating the paper from the back lightly with a propane torch, which actually gave me some results but only near the center. I heated the copper layer with the torch first, and actually destroyed a couple boards that way by applying too much heat from the torch. I did wind up getting vastly improved transfer this way as I rolled a piece of ~1.5″ aluminum pipe over it and VERY gently heated the paper with a torch.. but I was still left with an unusable amount of transfer.

So I was going to buy baking sheets today (aka cooking parchment, apparently) as I read that had excellent qualities for laserjet toner transfer. But before I ran to Walmart I was in Walgreens which is much closer to me. I picked up their glossy ink jet photo paper thinking I couldn’t do much worse than what I had already done. I learned that there were many thicknesses of glossy photo paper (The More You Know..) and this material actually had a paper back so it should fall apart in water and require less work for removal. I bought a cheap $18 iron while I was there. I’m not sure if it was the iron or the paper (but I’m betting it was mostly the paper with the iron not exactly hurting matters) but I got usable transfer on my first try. There was one little area where a large power trace was broken. I had the foresight in Walgreens to pick up fine-tipped Sharpies, so I scribbled in the broken trace and dumped the board in some Ferric Chloride.

<img class="wp-image-233" src="http://www.frank-d.info/wp-content/uploads/2015/09/First-JFET-PCB viagra 50 oder 100.jpg” alt=”First JFET PCB” width=”281″ height=”500″ />

First JFET PCB (theoretically 36 at a time)

This was a pretty good choice for a first etched PCB, I went through a bunch of layout iterations for each module that would be duplicated over the board, and I finally got something that I liked — the trace layout looked better to me than some of the other options and it was efficient in terms in space usage from left to right. I couldn’t fit a 5th row on the PCB without significantly reducing how many columns I had. I intended on using PCB terminals from Radio Shack (hence the 0.3″ spacing next to the resistors), but they were too bulky so I just soldered some Male-Male jumper wire to hook into the Arduino and the 8-way relay boards I ordered before I decided to start making PCBs. I’ll probably wind up integrating the relay board onto the JFET tester with an ADC and a header to connect directly to the Arduino. At least making PCBs is a cheap hobby, and I’ve always wanted to make SO many PCBs — I’ve always resorted to wiring on standard perfboard with thin wire and a decent amount of solder to work as ‘traces’ for audio amplifiers. PCBs would make things SO much easier — if only I had a small CNC mill to drill all the holes for me!

JFET DUT Cell Evolution -- From Really Bad to Kinda Bad!

JFET DUT Cell Evolution — From Really Bad to Kinda Bad!

 

As you can see, each DUT Cell has gotten smaller with time. The last one got slightly larger to accommodate the RS PCB Terminals, but they’d need even more space to properly fit. They hit the resistor on the cell it’s in and on the one before it.. then there’s little clearance even between the terminals so it’d be hard to insert wires.

I actually picked up an AVR ATMega2560 based board cheap at MicroCenter. I’ve been using AVRs forever, the Arduino IDE just makes things a little easier  in some respects, even if it is a bit more limiting than I’d like. I’m used to using Atmel’s stuff, I’ve been using AVRs since the first ATMegas came out and there was a long lead time on the 16MHz variants, so at least I’m fairly familiar with them and their inner workings. I couldn’t resist buying the ATMega2560 board as it has *16* ADC inputs without using an external multiplexer or ADC. I have a few ADCs laying around, but the only one I could find is a TLC1543IN which wouldn’t work with the Arduino Due without a level shifter as this particular model of the 1543 (IN) is a 5v part, so it would blow up the Due’s 3.3v IO without bi-directional level shifters which I don’t have.. nor do I have signal MOSFETs, and IRF510s in a TO-220 would look ridiculous even in the interim. 🙂

I’ve only physically populated a single row, and I used 1% metal film resistors (again from Radio Shack since they’re right there and I don’t have to wait for things even if I pay through the nose and out the other side of it).  Clearly I’m not an electronics engineer, and my circuit design is probably poor overall for some reason, but the JFETs will (hopefully) not oscillate and we’re only testing two parameters so it should suffice. I measured the resistors to make sure I was reading the bands correctly (it’s been a while and I don’t have a magnifying glass — and damn they’re harder to read than I remember), and my little Fluke thought they were all within +/- 1%. I didn’t want reading variations with 5% resistors.

The process is the same as before. The relays are flipped to measure IDSS or Vpp, and we use a single pin to flip the relays. We’ve just scaled it up some by taking it off of a breadboard. You can see the PCB I printed this time only does 36 FETs at a time. I was trying to minimize the area outside of the center of the board and these are just prototypes so there was no reason to not do so.

Speaking of, I have design decisions to make for my prototypes — either use ATTiny828s that have 4 ADCs and mux them out to 28 for a mere $2.24 each (in TQFP from DigiKey) and put them on board (say with 112 JFETs on a larger board) with serial uplinks or to a control processor either on or off the board. With only 512B of RAM they’d need a separate processor to offload readings as quickly as possible. At least it’s cheaper than a halfway decent ADC and leaves me room to update their firmware and possibly do things a bit differently.

Here’s an example of *90* JFETs in the same board space (4.5″x6.375″), up from 36. They’re packed in tight, but there’s enough clearance everywhere. This one uses 2 pin male headers for each JFET.. routing them to a central place for a ribbon cable would be nice, but would require a two sided layout which I’m not quite ready for yet..

90 JFETs on a 28 in^2 board

90 JFETs on a 28 in^2 board

So I’m going to wire the 12 JFETs up to a couple 8-relay boards and see what happens. Hopefully I didn’t screw up the circuit design from my breadboard layout and there’s nothing seriously wrong with the design..

Part 3 incoming, it’s either going to detail a massive failure and/or another upgrade.. hooray?

 

µC Prototype JFET Vpp/Idss Tester — scalable to 20-50+ at a time Phase I: The 4 Little JFETs That Could

I previously tested all my 2SK170 and 2SJ74 JFETs by hand with a simple circuit, it’s illustrated well at the Fetzer Valve page, which is a great resource on making a very simple JFET amplifier that somewhat mimics a tube sound. The schematic is near the bottom of the page. I used a DPDT switch and tested two JFETs at a time, then logged the results in a spreadsheet and put the JFETs on a roll of tape with a start number and end number corresponding to the ID in the spreadsheet.

Clearly I needed a way to automate this as some projects will need to many matched JFETs, or I’ll at least need to know their basic characteristics since they have a ridiculously wide manufacturing tolerance. This was a bit of a pain when I went to build my Discrete Class-A all JFET opamp on a breadboard. Side note: Sounds awesome as the initial input for my modular guitar amplifier project and drives the Fetzer Valve circuits into crunchy distortion, especially when the presence caps are engaged!

So I took the schematic and scaled it up. I used a Seeed relay shield attached to an ARM Cortex M3 based Arduino Due. An Arduino Uno would’ve also worked, but the Due has more ADCs and higher precision. This is just a prototype for a larger version, and a proof of concept. It tests 4 JFETs at a time since there are only 4 relays.

The relay shield acts the same as the SPDT switch shown to switch between Vpp and Idss measurement. Sending “R” to the Arduino over serial changes modes, and it just consistently prints out the measured values. I had tried to use the SPDT switch to trigger an interrupt, but I didn’t have any hardware debounce and the interrupt triggers were actually causing the µC to freeze up for some reason. I didn’t look into it and just figured it’d be easier to read the serial input.

The code is very simple and available on GitHub at https://github.com/fdimitri/Arduino_DUE_JFET_Tester. I set the relay pin low or high to measure Vpp or Idss then perform a few measurements and average them. The Due has a bunch of on-chip SRAM so storing 16 samples from 12 ADCs with 16 bit precision (12 bit with 4 bits of padding) doesn’t hurt in the least at 384 bytes of RAM of our 96kB total.

 

arduino JFET tester Phase I_rotated

Arduino JFET Tester Prototype

(Not shown: 9v battery source)

 

I used 1% metal film resistors so I could basically ignore calibration, though you could easily use 10% and measure them then set a calibration factor FOR EACH ADC. I’d rather spend a few extra bucks and deal with a maximum ~2% error factor.

The relays make a satisfying click as they all switch in synchronization. The JFETs are driven with what ever voltage I need, if you expect your values to exceed 3.3v on a Due you’ll have to add a voltage divider to your sampling line, and they’ll have to be very high resistance to not interfere with the JFET — which can also reduce sampling accuracy, ironically. You could also adjust the sense resistor in the circuit. I’ll post schematics with higher power JFETs to illustrate different tactics for dealing with high current JFETs or ones with a high Vgs(off)/Vpp.

The source voltage for the JFETs doesn’t affect Vpp/Idss to such a degree that I had to modify anything, Vpp never exceeds ~1.3v, and Idss never exceeds ~1.5v (which equates to 15mA) with my 2SK170s. You can also test P channel JFETs, but you have to modify a few things to do so. Again, I’ll be posting complete schematics for each type and what to do with high Vpp/Idss devices. The second version is going to use 24 relays and an extra 8 channel 10 bit ADC so I can measure 20 JFETs at a time.

I like to let them sit in each mode for a few minutes to stabilize temperature (as they’re rather) before actually recording the readings. All of these things are going to go into the software, and support for the Seeed boards will remain for a simpler JFET tester (even up to 3 boards if you’re up to wiring them) — however I really recommend the 8 relay boards with optocouplers that you can buy on eBay. The optocouplers protect your precious µC pins from anything as you trigger the relays.

Feeding the JFETs with 3.3v gave me wonky readings, and 5v wasn’t much better. 9v gives me pretty much the same readings as 30v with some small variance, so I’d recommend a 9v feed. You should protect your ADC inputs with at least Zeners (I didn’t).. or some type of break switch (ie any transistor).

So Phase 1: 4 Relays, Using 4/12 onboard 12 bit ADCs
Phase 2: 16 Relays, using 12/12 onboard 12 bit ADCs
Phase 3: 24 Relays, using 12/12 onboard 12 bit ADCs + external chip with 8 10 bit ADCs
Phase 4: Use RadioShack 276-170 boards with JFET sockets installed instead of breadboards (Two sections of 47 columns, 5 rows). That will easily give me 22 JFETs per board
Phase 5: Add more I2C ADCs and relays to test ~50 JFETs at a time for easy cataloging
Phase 7: Switch to STM32F429, test 100 JFETs at a time with many I2C ADCs (or use a hilarious amount of relays as a huge multiplexer instead of a massive ADC array — which also has the advantage of sounding really cool)

Since the Arduino Due is basically a monster as far as micros go, we won’t run into any issues with lack of RAM or PROM storage. Do you know how insane 96kB is when you came from 8kB and less of RAM? Granted it’s not as much as an improvement as the processor itself.. but still very nice! Of course I cheated back in those days and hooked up 64kB SRAM.. in banks.. and bank switches happened between task switches, so each process/task had its own bank of 32kB of RAM for the heap. But that’s a story for another day, and I digress!

I may also port the project to my STM32F429 Discovery board. It has 256kB of RAM with another 8MB on the PCB accessible and addressable through the external bus, along with a 320×240 touch-screen LCD. That would be an entirely new program, of course as unfortunately the STM32F boards are not really supported under Arduino (though apparently some work is being done for some of them.. the F429 is not one of those devices).

Between that and maybe an easier navigation device (track ball off a Blackberry? Joystick?) it’d certainly be a more impressive looking and easier to use tester. I know I don’t need that much RAM for this application, but I can’t argue with more specs 🙂 It also has a trio of I2C busses for hooking up LOTS of ADCs! It also sports I2S.. which means.. more ADCs!

And my secret end goal? To make a single ended JFET output stage to drive a small guitar amp. rezeptfrei viagra bestellen. shh! I’m gonna need lots of these things to drive a few amps into a speaker!

© 2017 Musings

Theme by Anders NorenUp ↑