Category: Electronics Workbench

Electrical & Electronic gadgets

More AAA-to-AA Alkaline Adapters

Having a handful of not-dead-yet AAA alkalines and a bunch of LED blinkies built for AA alkalines, a pair of adapters seemed in order:

AAA-to-AA Alkaline Adapters – installed

The blinkies need a somewhat wider base than they’d get from a pair of AAA alkalines, so it’s not quite as dumb as it may seem.

In any event, the positive terminal comes from a brass rod:

AAA-to-AA Alkaline Adapters – brass terminal

Nobody will ever see the fancy Hilbert Curve infill around the brass:

AAA-to-AA Alkaline Adapters – end view

In this application, they’ll go from not-dead-yet to oh-it’s-dead faster than AA cells, so I can watch how the blinkies work with lower voltages.

2020-09-23
Long-gone Labeling

These appeared while I was extricating the 3-axis positioner from an old project:

Migrated felt-tip pen labels

I’m reasonably sure those labels started with blue ink from my all-time favorite Ultra-Fine-Point Sharpie markers on address labels covered with ordinary matte tape. Fourteen years on, the X, Y, and Drive legends are pretty much indistinguishable.

Nothing lasts …

2020-09-19

Discrete LM3909: Blue LED Radome

Dropping a simplified ping-pong ball radome for a Piranha RGB LED atop a discrete LM3909 on the AA alkaline cell holder:

Discrete LM3909 Radome - AA alkaline — Discrete LM3909 Radome – AA alkaline

The solid model has screw holes for the lid and the revised LED spider:

Astable Multivibrator - Alkaline AA Base - radome - solid model — Astable Multivibrator – Alkaline AA Base – radome – solid model

The RGB LED needs only two wires, as the LM3909 circuit can blink only one LED. I tried all three colors, but only blue and green justify the LM3909 hairball; red can get along with the astable circuit.

The LED wires connect across a 1 MΩ resistor serving as a mechanical strut between the 9.1 kΩ resistor on the left and the 10 Ω ballast resistor on the right.

Fresh alkaline cells at 3.0 V put 3.3 V across the blue LED with a 37 mA peak current. Older cells at 2.3 V produce 2.9 V at 15 mA. Dead cells at 1.9 V still fire the LED with 2.7 V at 4.2 mA, although the flash is barely visible in ordinary room light.

The lovely blue ball looks better in person!

The OpenSCAD source code as a GitHub Gist:

	// Astable Multivibrator
	// Holder for Alkaline cells
	// Ed Nisley KE4ZNU August 2020
	// 2020-09 add LED radome

	/* [Layout options] */

	Layout = "Build"; // [Build,Show,Lid,Spider]

	/* [Hidden] */

	CellName = "AA"; // [AA] — does not work with anything else
	NumCells = 2; // [2] — likewise

	Struts = -1; // [0:None, -1:Dual, 1:Quad] — Quad is dead

	// Extrusion parameters

	/* [Hidden] */

	ThreadThick = 0.25;
	ThreadWidth = 0.40;

	HoleWindage = 0.2;

	function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit);
	function IntegerLessMultiple(Size,Unit) = Unit * floor(Size / Unit);

	Protrusion = 0.1; // make holes end cleanly

	inch = 25.4;

	//- Basic dimensions

	WallThick = IntegerMultiple(3.0,ThreadWidth);
	CornerRadius = WallThick/2;

	FloorThick = IntegerMultiple(3.0,ThreadThick);

	TopThick = IntegerMultiple(2.0,ThreadThick);

	WireOD = 1.5; // battery & LED wiring
	WireOC = 4;

	Gap = 5.0;

	// Cylindrical cell sizes
	// https://en.wikipedia.org/wiki/List_of_battery_sizes#Cylindrical_batteries

	CELL_NAME = 0;
	CELL_OD = 1;
	CELL_OAL = 2;

	// FIXME search() needs special-casing to properly find AAA and AAAA
	// Which is why CellName is limited to AA

	CellData = [
	["AAAA",8.3,42.5],
	["AAA",10.5,44.5],
	["AA",14.5,50.5],
	["C",26.2,50],
	["D",34.2,61.5],
	["A23",10.3,28.5],
	["CR123A",17.0,34.5],
	["18650",18.8,65.2], // bare 18650 with button end
	["18650Prot",19.0,70.0], // protected 18650 = 19670 plus a bit
	];

	CellIndex = search([CellName],CellData,1,0)[0];
	echo(str("Cell index: ",CellIndex," = ",CellData[CellIndex][CELL_NAME]));

	//- Contact dimensions

	CONTACT_NAME = 0;
	CONTACT_WIDE = 1;
	CONTACT_HIGH = 2;
	CONTACT_THICK = 3; // plate thickness
	CONTACT_TIP = 4; // tip to rear face
	CONTACT_TAB = 5; // solder tab width

	ContactData = [
	["AA+",12.2,12.2,0.3,1.7,3.5], // pos bump
	["AA-",12.2,12.2,0.3,5.0,3.5], // half-compressed neg spring
	["AA+-",28.2,12.2,0.3,5.0,0], // pos-neg bridge

	["Li+",18.5,16.0,0.3,2.8,5.5],
	["Li-",18.5,16.0,0.3,6.0,5.5],
	];

	function ConDat(name,dim) = ContactData[search([name],ContactData,1,0)[0]][dim];

	ContactRecess = 2*ConDat(str(CellName,"+"),CONTACT_THICK);
	ContactOC = CellData[CellIndex][CELL_OD];

	WireBay = 6.0; // room for wiring to contacts

	//- Wire struts

	StrutDia = 1.6; // AWG 14 = 1.6 mm
	StrutSides = 3*4;

	ID = 0;
	OD = 1;
	LENGTH = 2;

	StrutBase = [StrutDia,StrutDia + 25ThreadWidth, // ID = wire, OD = buildable
	FloorThick + CellData[CellIndex][CELL_OD]]; // LENGTH = base is flush with cell top

	//- Holder dimensions

	BatterySize = [CellData[CellIndex][CELL_OAL] + // cell
	ConDat(str(CellName,"+"),CONTACT_TIP) + // pos contact
	ConDat(str(CellName,"-"),CONTACT_TIP) – // neg contact
	2*ContactRecess, // sink into wall
	NumCells*CellData[CellIndex][CELL_OD],
	CellData[CellIndex][CELL_OD]
	];

	echo(str("Battery space: ",BatterySize));

	CaseSize = [3*WallThick + // end walls + wiring partition
	BatterySize.x + // cell
	WireBay, // wiring bay
	2*WallThick + BatterySize.y,
	FloorThick + BatterySize.z
	];

	BatteryOffset = (CaseSize.x – (2*WallThick +
	CellData[CellIndex][CELL_OAL] +
	ConDat(str(CellName,"-"),CONTACT_TIP))
	) /2 ;

	ThumbRadius = 0.75 * CaseSize.z;


	StrutOC = [IntegerLessMultiple(CaseSize.x – 2CornerRadius -2StrutBase[OD],5.0),
	IntegerMultiple(CaseSize.y + StrutBase[OD],5.0)];

	StrutAngle = atan(StrutOC.y/StrutOC.x);

	echo(str("Strut OC: ",StrutOC));

	LidSize = [2*WallThick + WireBay + ConDat(str(CellName,"+"),CONTACT_THICK), CaseSize.y, FloorThick/2];

	LidScrew = [2.0,3.8,7.0]; // M2 pan head screw (LENGTH = threaded)
	LidScrewOC = CaseSize.y/2 – CornerRadius – LidScrew[OD]; // allow space around screw head

	//- Piranha LEDs

	PiranhaBody = [8.0,8.0,8.0]; // Z = heatsink fins + body + lens height

	PiranhaPin = 0.0; // trimmed pin length beyond heatsink
	PiranhaPinsOC = [5.0,5.0]; // pin XY distance

	PiranhaRecess = PiranhaBody.z + PiranhaPin/2; // minimum LED recess depth

	BallOD = 40.0; // radome sphere
	BallSides = 4*StrutSides; // nice smoothness

	BallPillar = [norm([PiranhaBody.x,PiranhaBody.y]), // ID
	norm([PiranhaBody.x,PiranhaBody.y]) + 3*WallThick, // OD
	StrutBase[OD] + PiranhaBody.z]; // height to base of chord
	echo(str("Pillar OD: ",BallPillar[OD]));

	BallChordM = BallOD/2 – sqrt(pow(BallOD/2,2) – (pow(BallPillar[OD],2))/4);
	echo(str("Ball chord depth: ",BallChordM));


	//———————-
	// Useful routines

	module PolyCyl(Dia,Height,ForceSides=0) { // based on nophead's polyholes

	Sides = (ForceSides != 0) ? ForceSides : (ceil(Dia) + 2);

	FixDia = Dia / cos(180/Sides);

	cylinder(r=(FixDia + HoleWindage)/2,h=Height,$fn=Sides);
	}

	// Spider for single LED atop struts, with the ball

	module DualSpider() {

	difference() {
	union() {
	for (j=[-1,1]) {
	translate([0,j*StrutOC.y/2,StrutBase[OD]/2])
	rotate(180/StrutSides)
	sphere(d=StrutBase[OD]/cos(180/StrutSides),$fn=StrutSides);
	translate([0,j*StrutOC.y/2,0])
	rotate(180/StrutSides)
	cylinder(d=StrutBase[OD],h=StrutBase[OD]/2,$fn=StrutSides);
	}

	translate([0,0,StrutBase[OD]/4]) // connecting bars
	cube([StrutBase[OD]*cos(180/StrutSides),StrutOC.y,StrutBase[OD]/2],center=true);

	cylinder(d=BallPillar[OD],h=BallPillar[LENGTH],$fn=BallSides);
	}

	for (j=[-1,1]) // strut wires
	translate([0,j*StrutOC.y/2,-Protrusion])
	PolyCyl(StrutBase[ID],StrutBase[OD]/2,6);

	for (n=[-1,1]) // LED wiring
	rotate(n*90)
	translate([StrutOC.x/3,0,-Protrusion])
	PolyCyl(StrutBase[ID],StrutBase[OD],6);

	translate([0,0,BallOD/2 + BallPillar[LENGTH] – BallChordM]) // ball inset
	sphere(d=BallOD);

	translate([0,0,BallPillar.z – PiranhaRecess + BallPillar.z/2]) // LED inset
	cube(PiranhaBody + [HoleWindage,HoleWindage,BallPillar.z],center=true); // XY clearance

	translate([0,0,StrutBase[OD]/2 + WireOD/2 + 0*Protrusion]) // wire channels
	cube([WireOD,BallPillar[OD] + 2*WallThick,WireOD],center=true);

	}
	}

	//– Overall case with origin at battery center

	module Case() {

	union() {

	difference() {
	union() {
	hull()
	for (i=[-1,1], j=[-1,1])
	translate([i*(CaseSize.x/2 – CornerRadius),
	j*(CaseSize.y/2 – CornerRadius),
	0])
	cylinder(r=CornerRadius/cos(180/8),h=CaseSize.z,$fn=8); // cos() fixes undersize spheres!

	if (Struts)
	for (i = (Struts == 1) ? [-1,1] : -1) { // strut bases
	hull()
	for (j=[-1,1])
	translate([iStrutOC.x/2,jStrutOC.y/2,0])
	rotate(180/StrutSides)
	cylinder(d=StrutBase[OD],h=StrutBase[LENGTH],$fn=StrutSides);

	translate([i*StrutOC.x/2,0,StrutBase[LENGTH]/2])
	cube([2*StrutBase[OD],StrutOC.y,StrutBase[LENGTH]],center=true); // blocks for fairing

	for (j=[-1,1]) // hemisphere caps
	translate([i*StrutOC.x/2,
	j*StrutOC.y/2,
	StrutBase[LENGTH]])
	rotate(180/StrutSides)
	sphere(d=StrutBase[OD]/cos(180/StrutSides),$fn=StrutSides);

	}
	}

	translate([BatteryOffset,0,BatterySize.z/2 + FloorThick]) // cells
	cube(BatterySize + [0,0,Protrusion],center=true);

	translate([BatterySize.x/2 + BatteryOffset + ContactRecess/2 – Protrusion/2, // contacts
	0,
	BatterySize.z/2 + FloorThick])
	cube([ContactRecess + Protrusion,
	ConDat(str(CellName,"+-"),CONTACT_WIDE),
	ConDat(str(CellName,"+-"),CONTACT_HIGH)
	],center=true);

	translate([-(BatterySize.x/2 – BatteryOffset + ContactRecess/2 – Protrusion/2),
	ContactOC/2,
	BatterySize.z/2 + FloorThick])
	cube([ContactRecess + Protrusion,
	ConDat(str(CellName,"+"),CONTACT_WIDE),
	ConDat(str(CellName,"+"),CONTACT_HIGH)
	],center=true);

	translate([-(BatterySize.x/2 – BatteryOffset + ContactRecess/2 – Protrusion/2),
	-ContactOC/2,
	BatterySize.z/2 + FloorThick])
	cube([ContactRecess + Protrusion,
	ConDat(str(CellName,"-"),CONTACT_WIDE),
	ConDat(str(CellName,"-"),CONTACT_HIGH)
	],center=true);

	translate([-CaseSize.x/2 + WireBay/2 + WallThick, // wire bay with screw bosses
	0,
	BatterySize.z/2 + FloorThick + Protrusion/2])
	cube([WireBay,
	2LidScrewOC – LidScrew[ID] – 24*ThreadWidth,
	BatterySize.z + Protrusion
	],center=true);

	for (j=[-1,1]) // screw holes
	translate([-CaseSize.x/2 + WireBay/2 + WallThick,
	j*LidScrewOC,
	CaseSize.z – LidScrew[LENGTH] + Protrusion])
	PolyCyl(LidScrew[ID],LidScrew[LENGTH],6);


	for (j=[-1,1])
	translate([-(BatterySize.x/2 – BatteryOffset + WallThick/2), // contact tabs
	j*ContactOC/2,
	BatterySize.z + FloorThick – Protrusion])
	cube([2*WallThick,
	ConDat(str(CellName,"+"),CONTACT_TAB),
	(BatterySize.z – ConDat(str(CellName,"+"),CONTACT_HIGH))
	],center=true);

	if (false)
	translate([0,0,CaseSize.z]) // finger cutout
	rotate([90,00,0])
	cylinder(r=ThumbRadius,h=2*CaseSize.y,center=true,$fn=22);

	translate([0,0,ThreadThick – Protrusion]) // recess around name
	cube([0.6CaseSize.x,8,2ThreadThick],center=true);

	if (Struts)
	for (i2 = (Struts == 1) ? [-1,1] : -1) { // strut wire holes and fairing
	for (j=[-1,1])
	translate([i2StrutOC.x/2,jStrutOC.y/2,FloorThick])
	rotate(180/StrutSides)
	PolyCyl(StrutBase[ID],2*StrutBase[LENGTH],StrutSides);

	for (i=[-1,1], j=[-1,1]) // fairing cutaways
	translate([iStrutBase[OD] + (i2StrutOC.x/2),
	j*StrutOC.y/2,
	-Protrusion])
	rotate(180/StrutSides)
	PolyCyl(StrutBase[OD],StrutBase[LENGTH] + 2*Protrusion,StrutSides);
	}

	}

	translate([0,0,0])
	linear_extrude(height=2*ThreadThick + Protrusion,convexity=10)
	mirror([0,1,0])
	text(text="KE4ZNU",size=6,spacing=1.20,font="Arial:style:Bold",halign="center",valign="center");

	}
	}


	module Lid() {

	difference() {
	hull()
	for (i=[-1,1], j=[-1,1], k=[-1,1])
	translate([i*(LidSize.x/2 – CornerRadius),
	j*(LidSize.y/2 – CornerRadius),
	k*(LidSize.z – CornerRadius)]) // double thickness for flat bottom
	sphere(r=CornerRadius/cos(180/8),$fn=8);

	translate([0,0,-LidSize.z]) // remove bottom
	cube([(LidSize.x + 2Protrusion),(LidSize.y + 2Protrusion),2*LidSize.z],center=true);

	for (j=[-1,1]) // wire holes
	translate([0,j*WireOC,-Protrusion])
	PolyCyl(WireOD,2*LidSize.z,6);

	for (j=[-1,1])
	translate([0,j*LidScrewOC,-Protrusion])
	PolyCyl(LidScrew[ID],2*LidSize.z,6);

	}
	}


	//——————-
	// Build it!

	if (Layout == "Case")
	Case();

	if (Layout == "Lid")
	Lid();

	if (Layout == "Spider")
	if (Struts == -1)
	DualSpider();
	else
	cube(10,center=true);

	if (Layout == "Build") {
	rotate(90)
	Case();
	translate([0,-(CaseSize.x/2 + LidSize.x/2 + Gap),0])
	rotate(90)
	Lid();
	if (Struts == -1)
	translate([CaseSize.x/2,0,0])
	DualSpider();
	}

	if (Layout == "Show") {
	Case();
	translate([-CaseSize.x/2 + LidSize.x/2,0,(CaseSize.z + Gap)])
	Lid();
	}

view raw Astable Multivibrator – Alkaline Batteries – radome.scad hosted with ❤ by GitHub

2020-09-17

Discrete LM3909: Blue LED Waveforms
The circuitry and instrumentation is essentially the same discrete LM3909 as before:

LM3909 – blue – test setup

With a few minor tweaks:
- Blue LED, forward voltage 2.56 to 2.97 V
- 24 Ω R1
- One Q2 current mirror transistor driving Q3
With a pair of fresh AA alkaline cells producing 3.1 V (not the NiMH Duracells you see in the picture), the blue LED blinks brightly.

The 610 mV peak voltage across R1 shows the LED starts at 25.4 mA:

LM3909 blue – 3.1 V – R1 24 ohm

The capacitor reaches 1 V, then goes about 150 mV into reverse charge during the flash (note the different horizontal scales):

LM3909 blue – 3.1 V – C1 V

The Darlington version of Q1 seems to do a decent job of keeping the cap out of reverse charge. A Shottky diode would add a few hundred mV, but I doubt there’s anything nasty going on inside the cap as it stands.

The blue LED has a forward drop of 2.97 V at 20 mA, so I’m surprised the voltage across it hits 3.1 V at 25 mA:

LM3909 blue – 3.1 V – LED V

Very little of the voltage appears across Q3, the driver transistor:

LM3909 blue – 3.1 V – Q3 coll

With a pair of nearly dead alkaline cells for a 2.0 V supply, the LED current peak drops to 4.6 mA:

LM3909 blue – 2.0 V – R1 24 ohm

The LED lights brightly, then fades away exactly like you’d expect from that waveform.

The cap still charges to about 1 V and stays well above 0 V during the (much longer) flash:

LM3909 blue – 2.0 V – C1 voltage

The voltage across the LED now reaches only 2.7 V, which is substantially higher than the 2.0 V battery supply and exactly why the LM3909 existed:

LM3909 blue – 2.0 V – LED voltage

Q3 continues to saturate, although you can see the effect of the decreased base drive during the flash:

LM3909 blue – 2.0 V – Q3 coll

The blue LED won’t light at 1.3 V, but still gives out a weak flash at 1.7 V, so I’d say the tweaked LM3909 circuitry works reasonably well.
2020-09-16
Alkaline AA Astable vs. RGB and Yellow LEDs

A fresh pair of alkaline AA cells at 3.2(-ish) V can’t light a Vf = 3 V blue LED with any authority, but I laid out an astable multivibrator circuit with a Piranha RGB LED to see how the colors looked:

Astable AA Alkaline – build test

Lighting all three LEDs at once doesn’t make much sense, although I did try it just for the amusement. Spoiler: red wins, even with more-or-less equal currents.

Mounting the hairball on an AA alkaline holder looks better:

Astable AA Alkaline – RGB LED test

Red being the only LED color making any kind of sense meant the Piranha was overqualified for the job, so I replaced all that clutter with a simple 5 mm yellow LED:

Astable AA Alkaline – yellow

It’s shatteringly bright at 20 mA from fresh alkalines at 3.2 V and remains visible down to 1.8 V.

The original circuit schematic / layout doodle:

Astable wiring layout – Piranha RGB test

No surprise in any of this, as it’s why the discrete LM3909 circuitry happened, but it’s nice to have a simple LED atop some alkalines for show-n-tell. If, of course, show-n-tell events ever happen again …

2020-09-14
DSO150: USB Serial Output
Taking all those pictures of the DSO150 screen reminded me it has a data dump function: press the V/Div and ADJ buttons to squirt configuration, measurements, and trace data from the TX pad on the main board, just in front of the red-black power wires hot-melt glued in place:

DSO150 USB serial adapter – interior

The picture shows the “before” stage, while I was figuring out where to carve another hole in the case.

NB: The 113-15001-111 DSO150 firmware version includes the serial output option, so you won’t need third-party firmware. Similarly, current PCBs bring the serial pins to neatly labeled header pads. You should refer to the JYETech DSO150 / DSO Shell product page for the details.

After all the cuttin’ and filin’ was done, it looked like this:

DSO150 USB serial adapter – exterior

The power switch on the back of the case (top of the picture) disconnects the lithium cell from the charge controller board (now tucked behind the battery) to eliminate any trickle current discharge. Charging the battery thus requires turning that switch on and turning the scope off with its own power switch (along its front edge). Capturing trace data requires having both switches on (duh), whereupon the scope’s normal operating current convinces the charge controller that the cell hasn’t reached full charge. Turn the scope off and, most likely, the controller will tell you the cell is fully charged.

An intro blurb squirts from the port at 115200 in good old 8N1 format when you turn the scope on:
```
DSO Shell
JYE Tech Ltd.
WWW.JYETECH.COM
FW: 113-15001-111
```
Pressing the V/Div and ADJ buttons dumps the trace data:
```
VSen,0.5V
Couple,DC
VPos, -2.02V
Timebase,0.2s
HPos,00362
TriggerMode,NORM
TriggerSlope,Rising
TriggerLevel,  2.02V
RecordLength,01024
Vmax,  2.85V
Vmin,  0.24V
Vavr,  0.87V
Vpp,  2.61V
Vrms,  1.03V
Freq, 0.441Hz
Cycl, 2.266s
PW, 0.231s
Duty, 10.2 %
SampleInterval,00008ms
00000,0000000000, 0.8518688
00001,0000000008, 0.5273474
00002,0000000016, 0.5273474
00003,0000000024, 0.5476300
00004,0000000032, 0.5476300
00005,0000000040, 0.5476300
<< snippage >>
01015,0000008120, 0.8113037
01016,0000008128, 0.8315863
01017,0000008136, 0.8315863
01018,0000008144, 0.8315863
01019,0000008152, 0.8315863
01020,0000008160, 0.8315863
01021,0000008168, 0.8315863
01022,0000008176, 0.8518688
01023,0000008184, 0.8518688
```
It’s all in neatly comma-separated-value format, so you can slam it into a spreadsheet and have your way with it. Utilities also exist to capture the data, extract the values, and send them directly to GNUplot, etc.

Like so:

DSO150 test image

If I expected to do a lot of that, I’d boldify the traces and embiggen the text, all of which is in the nature of fine tuning.

It’s hard to reproduce the beauty of the DSO150’s display, though:

DSO150 test image

The DSO150 remains pretty good for being the worst oscilloscope I’m willing to use …
2020-09-11
Discrete LM3909 vs. DSO150 Scope

Although I’m a big fan of multi-channel scopes and Hall-effect current probes, a dirt-cheap single-trace oscilloscope can get you quite a ways to the goal:

LM3909 – DSO150 test setup

That’s a genuine JYETech DSO150 powered by an 18650 lithium cell and a boost converter set to 9 V. Make sure you get a genuine DSO150 from an authorized seller, rather than one of the myriad knockoffs; it doesn’t cost much more and tends to reward the right folks.

Anyhow, battery power means you can connect it directly across components to measure what would otherwise be a differential voltage:

LM3909 – Darl Q1 3x Q2 – 1.5 V – R1 V – DSO150

That’s the voltage across R1, the 39 Ω LED ballast resistor in the discrete LM3909 circuit running from a 1.5 V supply. Divide the 314 mV peak by 39 Ω to get 8 mA of LED current.

The voltage across C1, the timing and boost capacitor, looks like this:

LM3909 – Darl Q1 3x Q2 – 1.5 V – C1 V – DSO150

So the cap adds half a volt to the supply in order to put 2.0 V across the LED, which accounts for the relatively low current; the green LED has a forward drop of about 2.2 V at 20 mA and 1.9 V at µA-level current.

For completeness, the voltage across the LED:

LM3909 – Darl Q1 3x Q2 – 1.5 V – Green LED V – DSO150

So, yup, the LED really does see 2.0 V. I love it when the numbers work out.

Crank the supply to 3 V and see this across R1:

LM3909 – Darl Q1 3x Q2 – 3.2 V – R1 V – DSO150

The LED current is now 1.23 V / 39 Ω = 33 mA.

The capacitor just barely enters reverse charge:

LM3909 – Darl Q1 3x Q2 – 3.2 V – C1 V – DSO150

Pop quiz: what voltage to you expect to see across the LED?

I’ll leave further investigation to your imagination, but for low-frequency analog work, you can do worse than a DSO150.

2020-09-09