It's in wiki, but simply (and slightly badly) put: parallel is a short-circuit when it doesn't resonate, series is a short circuit when it does resonate

If you put the C in series with the L, assuming you don't accidentally pick the one C that is at resonance at 50Hz, you should see a change in the voltage on L and the current through L

Eh, not really, the chokes don't really do much with C, they are mostly intended as an L, which becomes high-resistance to high frequencies

The change in voltage and current is something an old fashioned analogue LC(R) meter uses with a known internal component to find L.

Many digital ones do the same thing, but with one fixed frequency and do the maths

The analogue ones are more fun though. They have an internal C, for example and an accurate frequency generator that you can adjust. But in stead of the frequency the dial says "uH" or "mH", and there's a meter that flips all the way to maximum at one given point: that's where it resonates, so then the dial indicates the inductance when the meter excites to maximum. The engineer building the device has done the maths and translated the frequency to inductance

Some are very fancy, they can even indicate the Q-factor and such by way of how much the needle goes up, or by re-adjusting the dial till it falls to "Q" and then subtracting and/or multiplying two numbers on another ring on the dial

Anyway

Etc

is prototyping electronics something you just learn by doing, or are there some good books/etal on the topic?

So, if you know the formulas behind LC circuits, ignoring the internal resistances, and you know the C and you know how much voltage and/or current changes, you can estimate the L.

You'll be off, because there is R in both the C and L, but first go will give you something. Then you add the C that should be much closer (but not at - or you'll get too much current from the socket) resonance and you try again

@Shalvenay As best I know it's both

If you only read you get lost in floaty theory that's always too rosey for the real world, if you only try you never learn why.

If there is an edition of Elektor in a language that works for you it might be a nice start.

...yeah. my problem is that I find myself trying to do all the trappings of a production-ready design w/ board layout etal before I prototype, and then I'll respin the board at basically the slightest provocation instead of using bodge wires

If you jump to a schematic/board design from an idea you need to have been "bread-boarding" for a while first, usually.

Bodge wires are a friend, but only if you can imagine/think about what might be happening, else you're just embroidering all over the place, and while it's fun to end up with an image of Donald Duck, that's not really useful to whomever wants the PCB next

yeah, and I generally don't breadboard either -- part of it is that I tend to select parts without reference to breadboard-ability

another part of that is that using devboards etal doesn't come naturally to me either

Devboards don't teach you to layout or prototype, they teach you what ever product the devboard is for

That is EXTREMELY useful

@Asmyldof -- I was speaking to uC devboards and such

well, breakouts even

And you should really teach yourself to use them

Yes, and as such, they teach you about the chip, not how to design something yourself

These days the learning curve seems to be: Arduino -> Breadboard -> Protoboard -> devBoard -> Eagle/Altium (-> Altium)

whereas, I learned how to lay out boards well before I was seriously into breadboarding

If you skip steps, that's fun for a bit and it may be a jump at first, but sooner or later you'll miss some of the basics in the upper layers

I had some idea of how a breadboard was to be used

It's not about the breadboard itself

It's about the trying and seeing

but it seemed at the time like with the surface-mount-itization of everything, that learning how to layout PCBs was the only way forward

It's much easier to think "Crap! Noise!" if you've had that 20 times before. And getting that and fixing that is 10 times easier on a breadboard

whereas, I start with a "decouple all the things!" mentality

and for big systems, I won't even try double sided -- I go straight to 4 layers

That was a shame then, because just the last 10 years the DIPs and such are so cheap

I mean -- when most of the parts you actually want to use aren't available in through hole...

nowadays it's worse even -- some parts aren't even available in gull-wing, which extra sucks

I have a feeling you just keep trying to jump in the pool at the edge that has the most water, in stead of seeing if the water's actually water over at the shalow end

The things you should be starting with are op-amps and transistors and amplification and logic and some PICs or Atmels. Not WSQFN-FloopyPAD-JipplePattern-SemiBGA super-function chips

...yeah. I wrap my head around OA circuits pretty well, and discrete logic quite well

(in fact, I'm so mentally predisposed to gate-and-FF thinking that it's a problem for me when I deal with HDLs)

but my problem is a systems prototyping problem

I've built circuits on breadboards

And then you do breadboarding and see all the imperfections and what the transfer functions do and why a square isn't a square most of the time

yeah, I've breadboarded individual circuits -- but like I said -- I'm very not-predisposed to prototyping systems

There is no system in prototyping, there's circuits that are chained. If you are unsure about the first one, you prototype that one to see what it does, if you have done that often enough to know the noises, current leaks, and all the rest, you put that in and prototype the next one, unless that's also know, then those two together become your known "I don't need to prototype this" circuit

If you know everything about a proc you are using, you aren't going to need to buy the dev board or hook it up to anything, but if you don't you do. And then you don't build "all the rest" and hope for the best, you hook it up to, let's say the first sensor or a sensor and a motor. That's prototyping

yeah

If I design something with an Atmel SAM, XMega, Mega or Tiny I just click'n'go - given all the rest is just as well known to me - but when two years ago someone asked me to build a complete analogue system next to the atmel, I bought all the dev boards

yeah, I have a F0 Discovery on that front

Because the analogue needed to be nA accurate, mV sensitive and completely fail-safe

but yeah...

I suppose I have an unhealthy fear of blowing up hardware, even though I've done it several times before?

I've done each of those before, but never at the same time, so then I say to that person "Give me € 1000 and a few weeks" and I will be in my lab for at least a week full time, often two or three

either that, or something about jury-rigging hardware together to a "just works" state puts me off. I don't quite have my finger on precisely what though...

Now, for own designs I've never spent more than € 50 on the prototyping, but for professional stuff, I buy the good shit

If it's the fear of blowing up, you are probably again going too big: getting too expensive stuff for your "test budget". For example, if you want to know whether an ATMega of € 7,- will be able to handle voltage X or current Y, you could know that from having done something similar once with a € 1,- Tiny. It may not be 100% sure, but if it's 90%, it's worth the risk of having an accident 1 in 10 times, but find new and exciting uses 9 out of the other 10

If it's fear of jury-rigging that makes me think that you need to do more of the experimenting that sometimes goes wrong (see ^^) to learn from it and get a feeling for when things work and why.

If a jury-rigged device "just works" for some reason, you haven't seen something that's going on. Happens to the best of us once in a while. But that shouldn't happen more than once every 20 and certainly not still be "magic" when we're done measuring, analysing and thinking, if that happens regularly, that's proof you need to do more experimenting - with anything op-amps or not, and ask other people when you don't know, where EE.SE and EEVBlog come in quite handy.

it also doesn't help that my failure modes when designing boards are of the "derpy" variety -- getting connector footprints wrong, footprinting an IC wrong, or not realizing that you specified GIGANTIC beads

getting a switch pinout cocked 90deg

Some of that comes from paying close attention, others come from the feeling that you get after some years of "200k at 100MHz, is that really a good idea?" or "mH, when was the last time I specced a series inductance as mH?"

moving a connector footprint too far back so that it doesn't fit on the board properly

and it's stuff I either a) don't even notice because I have no sense of scale in PCB design or b) agonize over and still get wrong

Most of those mean that 1: you're using the wrong library, or 2: you make the components yourself and refuse to be bitten by the "measure twice, cut once"-monster

If I'm making a PCB that goes into something that needs to work with something, I draw or print EVERYTHING I think up that I haven't printed before

When I started out computer-designing I was super happy about mils and how they could also be, like, 1.

Until I printed 10 tracks of 1 mil onto a transparency and found they had already become one single track fresh from the laser printer

And that was when laser printers, toner and transparencies were something you had to borrow from your dad's colleague and/or save up for

Of course, these days I know about tracks and clearances and everything that goes wrong in etching compared to your computer drawings and I don't print those any more. But, for example, I am now designing a complete device on my own at the office I am actually currently sitting in.

So that means doeing 3D cad design of a case, several PCBs, bought PSUs, protection switches, a large euro-plug with filter and fuse, Papst fans and also analogue signals that run close to digital ones.

doing*

Now, I know about mixed signal, so, that's cool. Start there, make the mixed signal design, test-print a few details to see in real-scale

For the rest, I can assume that most is okay, so I send it off for 3 units PCB, but, riddled with test-points for now and also later in case of defects due to missuse

They come back and I find: Ah, crap, used a pin that always needs to be 0 at start-up. So you get the scalpel, cut open the track somewhere that leaves enough trace on either side for a thin wire, hook it up swapped over: Use that pin for something that's always 0 at start and use the pin you used for that for the other thing. Change a pin-definition in a header file for your firmware: all done

Run all your other tests, they turn out to be great, so you change some cosmetic things you think could look nicer for the human eye, reroute the two tracks to be swapped as efficiently as possible: Product done at revision 2

Then there's the control board, here is a lot of electron kong-fu which I am not allowed to talk about, unless I want to be € 50000 poorer, but suffice it to say, I am now doing the final design and the board is stamped R09 in its solder mask for Revision 9

And the whole device isn't even done yet

Revision 0 through 3 were complete, but theoretical, those stupidities came out on printed paper, luckily

4 was a PCB that now rests somewhere in shreds at a recycling plant in China, I suspect. 5 was a PCB I fixed. 6 and 7 were theoretical because the specifications changed. 8 was a physical board that came from that

Worked well, but now the board also needs a solid-state relay thats butt-huge, so I am - again - redesigning

And I made a 3D model of all the things that surround the PCB just for this redesign, took me 2 days, put those 3D models into Altium parts that relate those 3D bodies to the PCB surface and/or mounting holes

And just a few hours ago I found a place where the relay will fit, because I can see on the resulting renders that everything is at least 20mm away all around it.

Had I now done those models and stuck to my first idea, I would be designing revision 10 in 3 weeks

now=not*