The Smell of Molten Projects in the Morning

Ed Nisley's Blog: Shop notes, electronics, firmware, machinery, 3D printing, laser cuttery, and curiosities. Contents: 100% human thinking, 0% AI slop.

Tag: Sewing

Fabric arts and machines

Kenmore 158 UI: Automatic Button Builder

Given the glacially slow Arduino touch-screen TFT display as a first pass UI for the Kenmore 158 sewing machine, I need some UI elements.

I need buttons. Lots of buttons.

Each button will have several different states that must be visually distinct:

Disabled – not available for pressing
Released – can be pressed and is inactive
Pressed – has been pressed and is now active

There may be other states, but those should be enough to get started.

I’d rather not draw that detail by hand for each button, so some tinkering with the Bash script driving the Imagemagick routines produced these results:

Aren’t those just the ugliest buttons you’ve ever seen?

The garish colors identify different functions, the crude shading does a (rather poor) job of identifying the states, and the text & glyphs should be unambiguous in context. Obviously, there’s room for improvement.

The point is that I can begin building the UI code that will slap those bitmaps on the Arduino’s touch-panel LCD while responding to touches, then come back and prettify the buttons as needed. With a bit of attention to detail, I should be able to re-skin the entire UI without building the data into the Arduino sketch, but I’ll start crude.

The mkAll.sh script that defines the button characteristics and calls the generator script:

./mkBFam.sh NdDn springgreen4 ⤓
./mkBFam.sh NdUp springgreen4 ⤒
./mkBFam.sh NdAny springgreen4 ⟳ 80 80 40
./mkBFam.sh PdOne sienna One 120 80
./mkBFam.sh PdFol sienna Follow 120 80
./mkBFam.sh PdRun sienna Run 120 80
./mkBFam.sh SpMax maroon1  🏃 80 80 40
./mkBFam.sh SpMed maroon2  🐇 80 80 40
./mkBFam.sh SpLow maroon3  🐌
montage *bmp -tile 3x -geometry +2+2 Buttons.png
display Buttons.png

As before, if you don’t see rabbit and snail glyphs, then your fonts don’t cover those Unicode blocks.

The quick-and-dirty mkBFam.sh script that produces three related buttons for each set of parameters:

# create family of simple beveled buttons
# Ed Nisley - KE4ZNU
# January 2015

[ -z $1 ] && FN=Test || FN=$1
[ -z $2 ] && CLR=red || CLR=$2
[ -z $3 ] && TXT=x   || TXT=$3
[ -z $4 ] && SX=80   || SX=$4
[ -z $5 ] && SY=80   || SY=$5
[ -z $6 ] && PT=25   || PT=$6
[ -z $7 ] && BDR=10  || BDR=$7

echo fn=$FN clr=$CLR txt=$TXT sx=$SX sy=$SY pt=$PT bdr=$BDR

echo Working ...

echo Shape
convert -size ${SX}x${SY} xc:none \
-fill $CLR -draw "roundrectangle $BDR,$BDR $((SX-BDR)),$((SY-BDR)) $((BDR-2)),$((BDR-2))" \
${FN}_s.png

echo Highlights
convert ${FN}_s.png \
  \( +clone -alpha extract -blur 0x12 -shade 110x2 \
  -normalize -sigmoidal-contrast 16,60% -evaluate multiply .5\
  -roll +4+8 +clone -compose Screen -composite \) \
  -compose In  -composite \
  ${FN}_h.png

convert ${FN}_s.png \
  \( +clone -alpha extract -blur 0x12 -shade 110x0 \
  -normalize -sigmoidal-contrast 16,60% -evaluate multiply .5\
  -roll +4+8 +clone -flip -flop -compose Screen -composite \) \
  -compose In  -composite \
  ${FN}_l.png

echo Borders
convert ${FN}_h.png \
  \( +clone -alpha extract  -blur 0x2 -shade 0x90 -normalize \
  -blur 0x2  +level 60,100%  -alpha On \) \
  -compose Multiply -composite \
   ${FN}_bh.png

convert ${FN}_l.png \
  \( +clone -alpha extract  -blur 0x2 -shade 0x90 -normalize \
  -blur 0x2  +level 60,100%  -alpha On \) \
  -compose Multiply -composite \
   ${FN}_bl.png

echo Buttons
convert ${FN}_s.png \
  -font /usr/share/fonts/custom/Symbola.ttf  -pointsize ${PT}  -fill black  -stroke black \
  -gravity Center  -annotate 0 "${TXT}"  -trim -repage 0x0+7+7 \
  \( +clone -background navy -shadow 80x4+4+4 \) +swap \
  -background snow4  -flatten \
  ${FN}0.png

convert ${FN}_bl.png \
  -font /usr/share/fonts/custom/Symbola.ttf  -pointsize ${PT}  -fill black  -stroke black \
  -gravity Center  -annotate 0 "${TXT}"  -trim -repage 0x0+7+7 \
  \( +clone -background navy -shadow 80x4+4+4 -flip -flop \) +swap \
  -background snow4  -flatten \
  ${FN}1.png

convert ${FN}_bh.png \
  -font /usr/share/fonts/custom/Symbola.ttf  -pointsize $PT  -fill black  -stroke black \
  -gravity Center  -annotate 0 "${TXT}"  -trim -repage 0x0+7+7 \
  \( +clone -background navy -shadow 80x4+4+4 \) +swap \
  -background snow4  -flatten \
  ${FN}2.png

echo BMPs
for ((i=0 ; i <= 2 ; i++))
do
 convert ${FN}${i}.png -type truecolor ${FN}${i}.bmp
# display -resize 300% ${FN}${i}.bmp
done

echo Done!

Now, to get those bitmaps from the SD card into the proper place on the LCD panel…

2015-01-16

Kenmore 158: Useful Unicode Glyphs
It turns out, for some reasons that aren’t relevant here, that I’ll be using the Adafruit Arduino LCD panel for the sewing machine control panel, at least to get started. In mulling that over, the notion of putting text on the buttons suggests using getting simple pictures with Unicode characters.

Herewith, some that may prove useful:
- Needle stop up: ↥ = U+21A5
- Needle stop up: ⤒=U+2912
- Needle stop down: ⤓ = U+2913
- Needle stop any: ↕ = U+2195
- Needle stop any: ⟳ = U+27F3
- Needle stop any: ⇅ = U+21C5
- Rapid speed: ⛷ = U+26F7 (skier)
- Rapid speed: 🐇 = U+1F407 (rabbit)
- Slow speed: 🐢 = U+1F422 (turtle)
- Dead slow: 🐌 = U+1F40C (snail)
- Maximum speed: 🏃 = U+1F3C3 (runner)
- Bobbin: ⛀ = U+26C0 (white draughts man)
- Bobbin: ⛂ = U+26C2 (black draughts man)
- Bobbin winding: 🍥 = U+1F365 (fish cake with swirl)
Of course, displaying those characters require a font with deep Unicode support, which may explain why your browser renders them as gibberish / open blocks / whatever. The speed glyphs look great on the Unicode table, but none of the fonts around here support them; I’m using the Droid font family to no avail.

Blocks of interest:
- Arrows: 2190 – 21FF
- Miscellaneous Symbols: 2600 – 26FF
- Supplemental Arrows-A: 27F0 – 27FF
- Supplemental Arrows-B: 2900 – 297F
- Miscellaneous Symbols and Pictographs: 1F300 – 1F5FF
The links in the fileformat.info table of Unicode blocks lead to font coverage reports, but I don’t know how fonts get into those reports. The report for the Miscellaneous Symbols block suggested the Symbola font would work and a test with LibreOffice show it does:

Symbola font test

An all-in-one-page Unicode symbol display can lock up your browser hard while rendering a new page.

Unicode is weird…
2015-01-14
Kenmore 158 LED Heatsink: Epoxy Sculpture

The LED mounting plate inside the sewing machine’s end cap sits 30° from the vertical axis of the needle. Even though the surface-mount LED emitters have a broad pattern, it seemed reasonable to aim them toward the needle to put the brightest spot where it’s needed.

The LEDs must have enough heatsinking to pull 2+ W out of the solder pads, so I figured I’d just epoxy them firmly to the mounting plate, rather than try to gimmick up a circuit board that would interpose a fiberglass slab in the thermal path.

Combine those two requirements and you (well, I) get a wire fixture that provides both power and alignment:

LED mount – wire fixture

The LED body is 5 mm square, sin(30°) = 0.5, and the rear wire raises contact end by 2.5 mm. This still isn’t an exact science; if the center of the beam lands in the right time zone, that’s close enough.

Testing the LED assembly at low current before entombing it shows the emitters have six chips in series (clicky for more dots):

LED mount – lighting test

The grotendous solder job follows my “The Bigger the Blob, the Better the Job” principle, modulated by the difficulty of getting a smooth finish on bare wires. Indeed, the first wires I painstakingly bent, set up, and soldered turned out to have an un-solderable surface, much like the header pins from a while ago. That hank of wire now resides in the copper cable recycling bucket; you’re looking at Version 1.1.

Two strips of Kapton tape under the ends of the wires hold them off the (scoured and wiped clean!) aluminum plate, with more tape forming a dam around the nearest edges:

LED mount – epoxy pour

Despite being steel-filled, JB Weld remains nonconductive, the epoxy-filled gap under the wires insulates them from the plate, the wires aren’t shorted together, and there’s a great thermal bond to the heatsink. Good stuff, that JB Weld!

A view from the back side shows the epoxy sagging over the wires before I added another blob:

LED mount – epoxy pour – rear

The LED assembly just sits there, without being anchored, until the epoxy cures. The epoxy remains thick enough (in the rather chilly Basement Laboratory) so that it doesn’t exactly pour, can be eased into place without too much muss & fuss, and stays pretty much where it’s put.

After the epoxy stiffened a bit, I gingerly positioned stranded wires not-quite-touching the LED wires and applied a dot of solder to each. Powering the LEDs from a bench supply at 500 mW each took the chill off the heatsink and encouraged proper curing:

LED mount – heated epoxy cure

Fast forward to the next day, return the heatsink to the Sherline, and drill a hole for the power cable. It’s centered between the wires in Y and between the fins in X, which is why I couldn’t drill before mounting the LEDs:

LED mount – drilling cable hole

It’s not like I’m building this from any specs…

Trim the wires, solder the cable in place, cover the wire ends & joints with JB KwikWeld epoxy, and it’s done:

LED mount – final epoxy

With the LEDs running their 230 mA rated current, the entire heatsink gets pleasantly warm and the mounting plate isn’t much warmer than that. I loves me a good JB Weld job…

However, I suspect they’ll shine too brightly at full throttle, which means an adjustable power supply looms on the horizon…

2015-01-06
Kenmore 158: Pulse Drive First Light
This worked right out of the box:

Pulse Drive – Tek 1 A-div

That’s roughly two half-cycles of the full-wave rectified AC with about 100 ms between pulses.

The upper trace comes from the differential amp, the lower trace from the Tek current probe at 1 A/div. The overall amp transconductance looks to be 1.3 A/V = 1.3 A/div, minus that small DC offset, so the ADC range is actually 6.5 A. That might be a bit too much, all things considered, but not worth changing right now.

Notice that the upper trace drops like a rock at the end of the pulse, while the Tek probe shows a gradual decrease. The missing current goes ’round and ’round through the flyback diode across the motor:

Pulse Drive – Flyback Diode – Tek 1 A-div

The Tek probe in the lower trace goes on the green wire connecting the diode to the bridge rectifier, oriented to match the diode polarity (+ current flows from motor to blue wire on collector to brown wire on rectifier to motor):

Motor flyback diode – installed

That nasty little spike in the middle of the diff amp output occurs when the collector voltage drops to zero and the ET227 shuts off, but the motor current continues to flow due to the winding inductance. In the first scope shot, the Tek probe doesn’t show any spikes in the motor current, because there aren’t any.

Compare that with the voltage and current of the motor running from an isolation transformer:

Rectified AC – 200 mA div – 875 RPM

As the pulse repetition frequency increases, the motor speed goes up and the current goes down:

Pulse Drive – Fast – Tek 1 A-div

The dropouts between successive pairs of half-cycles show where the firmware shuts off the current and goes once around the main loop.

The Arduino code making that happen:
```
PedalPosition = ReadAI(PIN_PEDAL);
if (PedalPosition > 190) {
	BaseDAC.setVoltage(Cvt_mA_to_DAC(3000),false);					// give it a solid pulse
	MotorDrive.ADCvalue = SampleCurrent(PIN_CURRENT_SENSE);			// measure current = half cycle delay
	MotorDrive.ActualCurrent = Cvt_ADC_to_mA(MotorDrive.ADCvalue);
	printf("%5u, %5u, %5u, %5u, %5u, %5u, %5u\r\n",
		MotorSensor.RPM,ShaftSensor.RPM,MotorDrive.State,
		MotorDrive.DACvalue,MotorDrive.ADCvalue,MotorDrive.ActualCurrent,PedalPosition);
	delay(3);														// finish rest of half cycle
	BaseDAC.setVoltage(0,false);									//  ... then turn it off

	delay(map(PedalPosition,190,870,100,0));						// pedal controls off time
}
```
The map() function flips the sense of the analog voltage coming from the pedal, so that more pedal pressure = higher voltage = lower delay. The pedal voltage produces ADC values from about 185 through 860, with a pleasant sigmoid shape that gives good speed control.

The maximum motor speed isn’t quite high enough for bobbin winding, but I like what I see so far!
2014-12-29
Kenmore 158: Recalibrated Hall Effect Sensor Amp

Reducing the differential amp gain fits a higher current into the Arduino’s fixed 5 V ADC range:

Hall Sensor Differential Amp

Those are 1% resistors, chosen from the heap for being pretty close to what I needed. Given that it’s an LM324 op amp, we’re not talking instrumentation grade results here.

The same calibration run that produced the DAC plot gave these values:

Current Calibrate – ADC – 270k Hall 2.7k opto

The linear fit gives the actual current, as seen by the Tek probe, for a given ADC reading.

The trimpot controls the offset voltage at zero current; working backwards, ADC = 0 corresponds to 140 mV, a bit higher than the actual 90 mV. Close enough, at least for a linear fit to eyeballed data, sez I.

Working forward, the maximum ADC value of 1023 corresponds to 4 A, which should suffice.

2014-12-24
Kenmore 158: Motor Flyback Diode

Although small power diodes make fine flyback diodes for relays, the motor can draw several amps during the startup pulse, which will be a bit out of spec for the usual 1N4007-class diodes. Pressing an old 5 A / 200 V stud diode into service produces the ungainly black-and-blue lump eating the end of the green wire:

Motor flyback diode – installed

For completeness, here’s the entire AC line interface part of the schematic:

AC Power Interface

The diode’s 200 V limit should suffice, even for cold starts at high line peaks, but, when you build this with new parts, get something rated a bit higher, OK?

The four NTC power thermistors lie just to the right of the relay, before the bridge rectifier.

2014-12-23
Kenmore 158: Pulse Drive
A Circuit Cellar reader sent me a lengthy note describing his approach to slow-motion AC motor drives, designed for an already ancient truck mounted radar antenna back in 1972-ish, that prompted me to try it his way.

The general idea is to pulse the motor at full current for half a power line cycle with an SCR (rather than a triac) at a variable pulse repetition rate: the high current pulse ensures that the motor will start turning and the variable repetition frequency determines the average speed. As he puts it, the motor will give off a distinct tick at very low speeds and the maximum speed will depend on how the motor reacts to half-wave drive.

Note that this is not the chopped-current approach to speed control: the SCR always begins conducting at the first positive-going 0 V crossing after the command and continues until the motor current drops to zero. There are no sharp edges generating high-pitched acoustic noise and EMI: silence is golden.

The existing speed control circuitry limits the peak current and assumes that the motor trundles along more-or-less steadily. That won’t be the case when it’s coasting between discontinuous current pulses.

When I first looked at running the motor on DC, these measurements showed the expected relationship:

Kenmore Model 158 AC Motor on DC – Loaded and Unloaded RPM vs Voltage

Later on, plotting RPM against current (50 mA/step starting at 550 mA):

Motor RPM vs Current Steps – Accelerating

Eyeballometrically, the slowest useful speed will be 2 stitch/s = 120 shaft RPM = 1300 motor RPM. At that speed, under minimal load, the motor runs on about 20 V and draws 550 mA. At that current, the 40 Ω winding drops 22 V, which we’ll define as “about 20 V” for this discussion, so the back EMF amounts to pretty nearly zilch.

That’s what you’d expect for the fraction of a second while the motor comes up to full speed, but in this case it never reaches full speed, so the motor current during the pulses will be limited only by the winding resistance. At the 200 V peak I’ve been using for the high-line condition, that’s about 5 A peak, although I’d expect 4 A to be more typical.

So, in order to make this work:
- the optocoupler driving the base needs more current
- the differential amp from the Hall effect sensor needs less gain
Given the ease with which I’ve pushed the hulking ET227 transistor out of its SOA, the motor definitely needs a flyback diode to direct the winding current away from the collector as the transistor shut off at the end of the pulse. Because it’s running from full-wave rectified AC, the winding current never drops to zero: there will definitely be enough current to wreck the transistor.

The firmware needs reworking to produce discrete pulses at a regular pace, rather than slowly adjusting the current over time, but that’s a simple matter of software…
2014-12-22