Archive for category Electronics

AoA sensor first prototype

I don’t see anybody selling an angle-of-attack sensor for FPV RC aircraft, so I’m making my own.

Here’s the first (quite crude) prototype:

AoA sensor prototype

It’s nothing more than a hall effect sensor inside a hollow tube (the black plastic spacer) with a magnet glued onto it. It’s held by the red plastic block with a hole drilled thru it.

The other end of the tube has a crude weathervane attached (the counterweight needs more work).

It seems to work reasonably well:

I’d feed the output into an ADC on a PIC.

The whole thing is too loosey-goosey for flight – this was just a prototype to see if the idea works.

Now I’m trying to figure out how to make a flightworthy version. Maybe this would be a good first 3D printer project?

Improved W4ZCB Latching Continuity Tester

Here’s a very simple low-voltage, low-current latching continuity tester circuit. The probe voltage is only ~ 49 mV and probe current is 1/2 mA maximum, so it’s safe for testing almost any board without risk of damaging something.

It’s a slightly improved version of Harold Johnson, W4ZCB‘s circuit published some years ago. (Not sure when; I found it here.)Improved_W4ZCB_Contunity_Beeper

R1/R2 and R3/R4 are voltage dividers; comparator U1 (an LM2903) turns on the beeper if the resistance between the probe leads is less than about 25 ohms.

I added C2 to make it latching; otherwise it’s very scratchy. The LM2903 is a smaller part than the original LM339, and I changed R4 from the original 10k ohms to 47k, to drop the continuity threshold from about 50 ohms to 25.

I used a TMB12A05 buzzer for LS1; these are available on eBay for about 20 cents each (quantity 10). Any small buzzer that buzzes by itself (with an internal oscillator) will probably work.

D1 and R5 just provide a power-on LED; you can omit them.

It’ll run on anything from about 3 to 15 volts (with the probe voltage about 1/100 of that); most any small-signal PNP transistor can be used for Q1.

This was drawn with DipTrace, which I’m experimenting with. So far I like it a lot – the user interface is far more intuitive than Eagle.

Webcam with privacy shutter & mute

Another business idea – this time a simple one.

Today the BBC has an article about “webcam hijackers” who blackmail people (mostly young women) with remote access trojans that grab webcam video.

I don’t get it. Why do almost no webcams come with a physical privacy shutter – just a sliding piece of plastic?

The right way to do this is a knob that turns a cam and slides a shutter in front of the lens.

It should have four positions:

  • Off – shutter blocks lens, cam opens a switch that electrically disconnects the microphone
  • Audio only – shutter blocks lens, cam closes mic switch
  • Video only – shutter away from lens, cam opens mic switch
  • On – shutter away from lens, cam closes switch

How hard is that, really?


Hey: VCs often say that good ideas are a dime a dozen. Mine go even cheaper than that. If you use this idea to make money, I’d like 0.5%. Of the equity in your company, or the profits. Or something. If that’s too much (or too little), fine – whatever you think is fair. This is a request for a gift, or reward – it is not a legal obligation. You’re free to use this idea and pay me nothing. If you can live with yourself that way.

Remove all comments from C and C++ source code

At the moment I’m struggling with Microchip’s new “Harmony” framework for the PIC32. I don’t want to say bad things about it because (a) I haven’t used it enough to give a fair opinion and (b) I strongly suspect it’s a useful thing for some people, some of the time.

Harmony is extremely heavyweight. For example, the PDF documentation is 8769 pages long. That is not at all what I want – I want to work very close to the metal, and to personally control nearly every instruction executed on the thing, other than extremely basic things like <stdlib.h> and <math.h>.

Yet Microchip says they will be supporting only Harmony (and not their old “legacy” peripheral libraries) on their upcoming PIC32 parts with goodies like hardware floating point, which I’d like to use.

So I’m attempting to tease out the absolute minimum subset of Harmony needed to access register symbol names, etc., and do the rest myself.

My plan is to use Harmony to build an absolutely minimum configuration, then edit down the resulting source code to something manageable.

But I found that many of Microchip’s source files are > 99% comments, making it essentially impossible to read the code and see what it actually does. Often there will be 1 or 2 lines of code here and there separated by hundreds of lines of comments.

So I wrote the below Python script. Given a folder, it will walk thru every file and replace all the .c, .cpp, .h, and .hpp files with identical ones but with all comments removed.

I’ve only tested it on Windows, but I don’t see any reason why it shouldn’t work on Linux and Mac.

from __future__ import print_function
import sys, re, os

# for Python 2.7
# Use and modification permitted without limit; credit to requested.

# thanks to zvoase at
# and Lawrence Johnston at
def comment_remover(text):
    def replacer(match):
        s =
        if s.startswith('/'):
            return " " # note: a space and not an empty string
            return s
    pattern = re.compile(
        re.DOTALL | re.MULTILINE
    r1 = re.sub(pattern, replacer, text)
    return os.linesep.join([s for s in r1.splitlines() if s.strip()])

def NoComment(infile, outfile):
    root, ext = os.path.splitext(infile)
    valid = [".c", ".cpp", ".h", ".hpp"]
    if ext.lower() in valid:
        inf = open(infile, "r")

        dirty =
        clean = comment_remover(dirty)

        outf = open(outfile, "wb") # 'b' avoids 0d 0d 0a line endings in Windows
        print("Comments removed:", infile, ">>>", outfile)

        print("Did nothing:     ", infile)

if __name__ == "__main__":
    if len(sys.argv) < 2:

        print("C/C++ comment stripper v1.00 (c) 2015")
        print("Syntax: nocomments path")

    root = sys.argv[1]
    for root, folders, fns in os.walk(root):

        for fn in fns:
            filePath = os.path.join(root, fn)
            NoComment(filePath, filePath)

To use it, put that in "", then do:

python foldername

Of course, make a backup of the original folder first.

Why is computer RAM disappearing?

For almost 30 years, roboticist Hans Moravec has been maintaining a great database of historical computer benchmarks going all the way back to 1891 (even before Hollerith tabulators).

This can be used to make nice plots showing Moore’s Law like this one (source XLS here):



But – here is something way more interesting.

The graph below plots, for each historical machine, the ratio of RAM (megabytes) to MIPS. So a machine with the same bytes of RAM as instructions/second rates as 1. One with 10x more bytes of RAM than instructions it can execute in a second rates as 10, etc.

I think of this ratio as “seconds” – if each instruction can access one byte, then the ratio gives the number of seconds needed to access all the RAM. (Of course this is a rough measure, as architectures differ, but good enough to give interesting results).

Here’s what I get:


Look at that! 

These are real historical machines with the given installed RAM (not how much RAM the machine could address, but the amount the machines actually had installed).

I’m just plotting the ratio of installed RAM to execution speed – it has nothing to do with price (except insofar as price may have affected buying decisions).

The ratio of RAM to machine speed has been steadily dropping. Why?

I remember a rule of thumb, probably from the 1980s, that a practical computer typically has about 1 second of of RAM – that is, a typical machine is fast enough to access all its memory in about 1 second.

This made sense at the time based on the idea that, in a command-line driven system, one second was about as long as users were willing to wait for a response. Longer was too slow, and shorter didn’t gain much.

But this graph is illuminating. The only explanation I can think of is that with the gradual transition from batch computing (many minutes is an acceptable run time), to interactive command lines (seconds) to GUIs (tens or hundreds of milliseconds), the ratio of RAM to MIPS has been steadily dropping.

But if that’s correct, I’d expect more in the way of a step function.

I suspect it’s something else, and that it’ll keep going. Something more interesting. But what?

Hewlett Packard > Agilent > Keysight … WTF?

What a way to ruin a great brand. For no apparent reason at all.

They could have called it “Pewlett Hackard”. Heck, they could have called it “Tektronix”. (Those guys in Beaverton seem to have no use for that name anymore.)

The monkeys are running the henhouse. (Or, um, something like that.)

Oh, and…get off my lawn!

Saleae Logic Analyzer

I’ve had this thing in my drawer for 2 years; just got to use it for the first time yesterday.

It’s fantastic – really worth $150.

Saleae Logic Analyzer

Saleae Logic Analyzer

Now they have new versions that do analog, too (low-bandwidth, tho).

The nice thing about the Saleae thing is the software – it’s really amazingly simple and effective (you can download a demo from their website without the hardware).

I’ve used other logic analyzers – this is miles ahead. (Also way, way, better than the protocol decode on my new Rigol DS2072A DSO.)

[No, they didn’t pay me anything to write this.]

Solar powered bike

I built a solar-powered bike. It works, but not quite as well as I’d hoped.

IMG_20130806_120725 copy

I started with a 2008 Currie “E-Zip Mountain Trailz” (sic; ugh) electric bike, which works pretty well.

That is powered by a pair of 12v 10AH SLA batteries, in series for 24 volts. I’ve always been afraid to ride for long distances for fear I’d run out of power before getting home. (The thing weighs 70 pounds, and I’m no athlete, so it’s painful to go up hills without power.)

I’d been thinking of putting solar panels on it to charge the batteries while I ride. I didn’t have any appropriately-sized panels around, so I didn’t do it until this summer, when I decided to try using a bike trailer to hold the panels.

The trailer solves the problem of the panels being shaded by my body when I ride, and also avoids problems with the weight of the panel hardware messing up the balance of the bike.

I have some 20 year old Siemens SM55 modules, rated at 55 watts (new, when pointed at the sun). These things are huge and heavy – 51 x 12 inches, and 12 pounds each (1300 x 330 mm, 5.5 kg). And since the eBike runs on 24 volts, I’d need 2 panels in series to charge the battery (at least without a DC-DC boost converter). That’s 24 pounds, not counting mounting hardware.

But, hey, with a trailer, who cares how much it weighs, right? And 110 watts is a lot of power – likely enough to completely power the bike while riding (on average, on a sunny day).

So I got a used bike trailer; $50 on Craigslist:

The bike trailer as I got it

The bike trailer as I got it (nylon roof & child seat removed)

I took off some of the trailer hardware to make it easier to mount the panels, and installed a plywood floor to make a storage compartment under the panels.

Then I used a couple of pieces of lumber to attach two panels together (at the ends), and mounted more lumber on the sides for mounting on the trailer. I cut slots to fit the trailer poles, and attached the panels to the trailer using standoffs and cable ties:

Cable tie straps hold the panels on

Cable tie straps hold the panels on

I also had to use more lumber to reinforce the trailer poles, which were only meant to hold a nylon sunshade (not 30+ pounds of panel hardware).

I was going to get a 24v charge controller to avoid putting too much voltage into the batteries, but I haven’t gotten around to that – I just wired the output of the panels (in series) parallel with the 24V battery; good enough for now.

Solar panel output wired in parallel with the battery

Solar panel output wired in parallel with the battery

"Watts-Up" meter is just used as a voltmeter. The venerable Garmin GPS V is also powered off the 24v system.

“Watts-Up” meter is just used as a voltmeter.
The venerable Garmin GPS V is also powered off the 24v system.

Finally, I made a bumper sticker to go on the back of the panel; it reads “CAUTION – HIGH CURRENT STAND BACK 500 MM” (just visible in the last picture below, if you zoom in). I figured that would keep the ignorant from messing with the bike (and it fits my skewed sense of humor).

So, how does it work?

It works. Mostly, sort of. As long as I’m riding in full sunlight I can go indefinitely if the road is level or not too steep.

I tried a test run riding to work – about 12 miles – on a sunny day.

I weigh nearly 220 pounds, the bike is 70 pounds, and the trailer with the panels is something like another 50 pounds. So the whole setup is maybe 350 pounds. That’s too much for the motor to pull up a steep hill without a lot of help from me.

I got to work OK and not too tired, in about 90 minutes (about 8.2 mph average – not at all impressive by road bicyclist standards). I did have to work my way up hills.

At work I got delayed and ended up going home close to dusk. I started out riding in the shade. Halfway home, I had a dead, dead battery and about 7 miles still to go. And 350 pounds to drag up each hill. After mighty struggles, I gave up and called for a ride home.

A week or so later, I tried the same trip on a light steel street bicycle (about 20 pounds, with narrow smooth tires and no suspension – in other words, efficient).

I got to work again in about the same time, only slightly more tired than with the electric bike. With the vastly lighter and more efficient bike, going up hills with that was no harder than with the solar bike (with the motor helping). And I was able to get home with no problem.

In the end, a simple street bike turned out to be just as fast, not much more effort to ride, and way more practical – it even works in the shade.

But it was fun to try.



OpenSCAD is great stuff! (Part 2)

[This is Part 2 of this post; click here for the first part.]

OpenSCAD is an open-source (completely free) 3D solid CAD program; it works on Windows, Linux, and Mac OS X.

It calls itself “The Programmers Solid 3D CAD Modeller”, and indeed that’s what makes it special.

Unlike any other CAD system I’ve seen, OpenSCAD is driven entirely by a program-like script. That sounds like it would be a lot harder to use than a GUI-based CAD system – but it’s not! It’s much easier to use, with a much shorter learning curve. The scripts use a C-like syntax that will be instantly familiar to anyone who’s worked even a little with C or a C-derived braces-and-semicolon language (C++, Java, C#, etc.).

In 15 minutes with OpenSCAD, I was able to do far more than I could with AutoCAD or SketchUp after several hours – with a lot less frustration. If you have any background in programming at all, you’ll find it ridiculously easy to learn and use.

OpenSCAD has a simple but effective IDE, so you can try things interactively at the keyboard – just type some commands, mash F5, and see the result instantly. Once your 3D model is rendered, you can use the IDE to zoom in and out and look at your model from any angle.

OpenSCAD showing my modeled speaker set

OpenSCAD showing my modeled speaker set

What makes OpenSCAD great for engineering drawings is it’s ability to position and size things numerically – if you want a part exactly 3.75 inches to the left of another part, just subtract 3.75 from the x-coordinate of the part, and that’s where it will be. If you want a part to be tall enough to cover 9 other parts, just get the dimensions of the other parts, add them up (in your script) and feed the result in as the height value.

That way, if you resize one part of your model, all the other parts that depend on it for their own size and position automatically get adjusted to compensate. If you want something centered with respect to some dimension, just take the dimension and divide it by 2 to get the proper position!

None of this is “magic” performed by OpenSCAD – this is stuff done by you, in your own script (program), so it’s 100% under your control.

For example:

cube([w, h, d]);

Gives you a rectangular prism with the given width, height and depth. “w”, “h”, and “d” can be literals – so cube([1,4,9]); gives you a 2001-type monolith. Or they can be program variables, which you can pass to a module and whose values you can compute.

There are commands to translate, mirror, and rotate objects (or groups of objects), and you can assign colors and transparency to them (but not textures, yet anyway). All the basic arithmetic and trigonometry functions are there to help you compute sizes, positions, and angles. And you can construct objects by any combination of adding or subtracting primitives (rectangular prisms, cylinders, spheres, and polyhedrons).

Conditionals and iteration are available with C-like “if” and “for” statements, so you can write a “real program”.

One unexpected thing is that the compiler is somewhat primitive – all variable values are computed at compile time (not “run time”); this has to be kept in mind when writing scripts, but I didn’t find it a serious problem.

The OpenSCAD website has an excellent manual (by freeware standards) that explains all this, as well as a handy “cheat sheet” for quick reference.

So far, I’ve used OpenSCAD only for this one project, and that took just a few hours – most of the time was spent tweaking the design of my speaker case. (Unlike all the other CAD programs I tried, hardly any time was spent figuring out how the program works.)

However, I quickly found a few tricks worth mentioning:

module part(name, w, h, d) {
cube ([w, h, d]);
echo (name, w, h, d);

This defines a module (something like a function) called “part”, which I use to define each separate part I’ll have to cut out of plywood to assemble the speaker set. Each part has a name, width, height and depth, and when the part is rendered, it prints out (via the “echo” statement) the name and dimensions, so I get a automatically-generated “cut list” of parts to make.

For example, I have this code:

module base(x,y,z) { translate([x,y,z]) { part(“Base”, BaseW, BaseH, BaseD); } }

This defines a module “base” that will create the base of the speaker case, using the dimensions in the variables BaseW, BaseH, and BaseD. The x, y, z inputs to the module give the position where the base should be.

Later in my script, I call:


Which creates the base of the speaker set, positioned at the origin of my coordinate space. It also prints the output:

ECHO: “Base”, 14.375, 0.75, 4.75

Which gives me the dimensions I need to cut to make the base. (The print formatting abilities of the script language are minimal, but adequate for this purpose.)

Here is the first part of my final script – it gives you an idea of how I calculated the dimensions of parts:

// Case for HelderHiFi amplifier, power supply, and speakers. 2013-03-27,


slop = (1/16); // inches
PartAlpha = 0.5;


AmpH = 1.75;
AmpW = 2;
AmpD = 5;

SpeakerW = 4.5;
SpeakerH = 7.25;
SpeakerD = 4.5;

BatteryW = 3.5;
BatteryH = 2.75;
BatteryD = 4;

PowerW = 3.35;
PowerH = 2;
PowerD = 3.5;


Thick = 3/4; // for load-bearing base, top, supports
ShelfThick = 1/4;
StripThick = 1/8;

StripLip = 1/4;

TopW = 8.5;

PlateThick = StripThick;


BaseW = slop + SpeakerW + slop + Thick + slop + BatteryW + slop + Thick + slop + SpeakerW + slop;
BaseH = Thick;
BaseD = max(max(max(AmpD, SpeakerD), BatteryD), PowerD) – 2*StripThick;

The idea here is that I’m allowing a “slop” of 1/16th inch – this is extra space beyond what is strictly needed per the component dimensions, to allow something for clearance and imperfect cuts.

Then I have the dimensions of the parts that need to fit inside the speaker case, and then the thickness of the plywood stock (3/4, 1/4, 1/8″) I’m going to use for different parts. Finally, from those I calculate the dimensions of the base – the width of the base is the sum of all the parts it has to hold, plus two “Thick” dimensions (for the vertical pillars), and slop around each of the parts. The base depth is calculated as the maximum of all the parts it will have to support, less “2*StripThick”, subtracting for retaining strips on either side of the base, which will be used to prevent the speakers from sliding off the base while being carried.

You can download my whole script here if you want to see it – I’m certain others have made vastly more complex and impressive things with OpenSCAD, but this shows what can be done after just a few hours of work.

When I run the script with F5, I get the rendered model:

Speaker set model. Grey boxes are speakers (translucent), blue box is amplifier. (Note the top, plus 1/8" lip around the speakers, prevent speakers from falling out unless carefully lifted.)

Speaker set model. Grey boxes are speakers (translucent), blue box is amplifier. (Note the top, plus 1/8″ lip around the speakers, prevent speakers from falling out unless carefully lifted.)

And this output:

Parsing design (AST generation)…
Compiling design (CSG Tree generation)…
ECHO: “Base”, 14.375, 0.75, 4.75
ECHO: “Long strip”, 14.625, 1, 0.125
ECHO: “Long strip”, 14.625, 1, 0.125
ECHO: “Short strip”, 0.125, 1, 4.75
ECHO: “Short strip”, 0.125, 1, 4.75
ECHO: “Pillar (less subtraction)”, 0.75, 7.625, 5
ECHO: “Pillar remove”, 0.25, 0.125
ECHO: “Pillar remove”, 5.875, 0.125
ECHO: “Pillar (less subtraction)”, 0.75, 7.625, 5
ECHO: “Pillar remove”, 0.25, 0.125
ECHO: “Pillar remove”, 5.875, 0.125
ECHO: “Shelf1”, 3.625, 0.25, 4.75
ECHO: “Shelf2”, 3.625, 0.25, 4.875
ECHO: “Power strip”, 3.625, 0.5, 0.125
ECHO: “Plate”, 5.125, 5.625, 0.125
ECHO: “Top”, 8.5, 0.75, 5
ECHO: “Clearance for speakers above lip”, 0.125
Compilation finished.
Compiling design (CSG Products generation)…
PolySets in cache: 15
Polygons in cache: 90
CGAL Polyhedrons in cache: 0
Vertices in cache: 0
Compiling design (CSG Products normalization)…
Normalized CSG tree has 21 elements
CSG generation finished.
Total rendering time: 0 hours, 0 minutes, 0 seconds

As you can see from the last line, this simple project renders nearly instantly.

From the cut list, I was able to go to my wood shop and cut out all the parts, ready to assemble:

Speaker set parts, per the cut list

Speaker set parts, per the cut list


I quickly piled the pieces together to see if they really fit with the components…

Front view. (Amplifier will go on top shelf.)

Front view. (Amplifier will go on top shelf.)

Back view.

Back view.


…and they did! Perfect on the first try!


Here’s the case part way thru assembly:

Case partially assembled.

Case partially assembled.


And the finished product, painted and wired up:


Front view.

Front view.

Back view.

Back view.

It sounds good, too.

OpenSCAD is great stuff! (Part 1)

It all started with a pair of Radio Shack Optimus Pro 7 bookshelf loudspeakers I picked up on eBay for a song.

These little speakers sound fantastic for their size, and at one time you could get them new at Radio Shack really cheap – I’ve been using a pair of white Pro 7AVs (the magnetically-shielded version) since the mid-90s as my PC desktop speakers.

Pro 7AV speakers (photo courtesy of Wade's Audio and Tube)

Pro 7AV speakers (photo courtesy of Wade’s Audio and Tube)

One day I was procrastinating by surfing eBay, ran across a black pair that looked nice, put in a bid, and soon had them in my basement, waiting for a project to use them.

Then I noticed the existence of low-cost TriPath TA2020-based amplifiers like this very popular one from Lepai. These things get fantastic reviews – the TA2020 uses PWM amplification and its distortion sounds like tube (valve) amplifier distortion. And audiophiles have been paying outrageous prices for tube amplifiers ever since tubes went out of style. Yet these TA2020 amplifiers go for 20 bucks! (And, yes, I know putting “audiophile” and “outrageous prices” in the same sentence is a bit redundant, but I’m not getting into that now.)

You may have figured out by now that I just can’t resist cheap things that deliver ridiculous value – it’s a character flaw. So combine the cheap-but-great loudspeakers with the cheap-but-great amplifier, and I just had to do something with them.

I decided to make a set of portable Bluetooth speakers. I’ve bought a few different Bluetooth loudspeakers and they all sound terrible to my ears; even the way-overpriced Bose ones sound bad to me (and I’m too cheap to pay that much anyway). So I thought I’d make my own.

There’s a guy Arjen Helder in Shenzhen (arjenhelder_electronic on eBay) who makes very well-reviewed TA2020 amplifiers, and he has a model “TA2024 MKV Bluetooth” with the Bluetooth module already built in. So 20 pounds sterling later (“Approximately US $30.35”), I’ve got one of those and I’m ready to start.

Helder HiFi TA2024 MKV Bluetooth amplifier

Helder HiFi TA2024 MKV Bluetooth amplifier

I wanted my speaker set to be portable, so that means they need a battery, and I happened to have an old 12V 5AH AGM battery around. Since the amplifier runs on 12VDC, that seemed a good fit. And I had a spare Harbor Freight 12V charger too ($9.99; did I mention I’m cheap?), so I figured I’d use that to both charge the battery and power the amp while it’s plugged in.

12V 5AH SLA battery and $9.99 Harbor Freight charger. (Not quite to the same scale...)

12V 5AH SLA battery and $9.99 Harbor Freight charger. (Not quite to the same scale…)

(Yes, I’m going to get to OpenSCAD. Be patient!)

So now I had most of the bits and pieces, and needed to come up with a design for the speaker set. I wanted a handle (to make it more portable; the speakers and lead-acid battery are heavy) and a place to wind some extra speaker cable, so I could separate the speakers for better stereo. That meant the speakers had to be held in a way that allows removing them, yet at the same time I didn’t want them to fall out by accident while carrying the set by the handle.

So I started sketching on paper. Here’s one of the earlier sketches:

Sketch1OK, so I’m not a good artist.

But the important thing was to get the dimensions right. I wanted it to be compact, but have room for all the pieces. (BTW, I hate using inches and fractions as much as anyone, but I’m in the US and lumber here only comes in those dimensions, so I’m stuck with them.)

As I made each sketch, I realized there were opportunities for improvement (perfectionism is another of my character flaws), so first I’d scratch things out, then at some point I’d start a whole new sketch:


and another:


and another:



This was frustrating. Any little change cascaded all across the design, and it was easy to make a mistake in calculating dimensions.

So I decided to see if I could find some simple CAD program to help. I spent some time communing with Google, and decided that SketchUp (ex-Google SketchUp, now owned by Trimble) was the way to go.

I spent a few hours learning to use it, and made moderate progress getting my design into the program:

How far I got with SketchUp

How far I got with SketchUp

However, I found it very difficult to transfer the dimensions from my paper sketches into SketchUp; there didn’t seem to be any direct way to force SketchUp to size things exactly, or to position parts at particular offsets with respect to other parts. SketchUp, although it’s far simpler than most “serious” CAD programs, still has a long learning curve, and it didn’t seem very well suited to the kind of engineering drawings I was trying to do. I could easily get things close, but couldn’t get them exact (I suppose there must be a way to do it, but I didn’t figure it out).

After trying and getting stuck for a few hours, I went looking for a better solution.

And that’s when I found OpenSCAD.

[To be continued in Part 2…]