Tag: Sewing

Although I plan to servo the motor speed to the pedal position, a quick open-loop test seems in order. The motor requires nigh onto half an amp before it can spin the sewing machine shaft, so this chunk of Arduino code scales-and-offsets ten bits of pedal position voltage into twelve bits of DAC output that produce a corresponding current limit for the motor winding:

ADCvalue = (word)analogRead(PIN_PEDAL);
DACvalue = map(ADCvalue,0x0100,0x03ff,0x0800,0x0fff);
dac.setVoltage(DACvalue,false);

Putting that in the Arduino’s main loop and holding the pedal down produces this pleasant result:

The current sense amp output in the top trace is scaled at 525 mA/V = 525 mA/div and the bottom trace is from the Tek current probe at 200 mA/div. Fiddling with the scope’s gain & offset exactly overlays the two traces and they remain overlaid through the full pedal travel, so the ferrite toroid isn’t saturating and the output remains nicely linear.

The flat tops in that picture show the ET227 transistor limiting the motor current to 600 mA, exactly the way it should.

Of course, the LM324 has a GBW = 1 MHz and, with a gain of three, a bandwidth of barely 300 kHz, so there’s a distinct lack of fuzz on that trace compared to the Tek probe’s 10 MHz bandwidth.

It’s easy to hold the sewing machine at a constant speed with a constant load, but touching the handwheel stalls the motor at a constant pedal position. Similarly, releasing the handwheel causes a runaway, unless I let up on the pedal fairly quickly.

Setting the Tek probe to 500 mA/div and triggering on a somewhat higher current while stomping on the pedal and grabbing the sewing machine’s handwheel shows the current increasing with the motor under heavier load:

The current limit reaches just under 2 A, over on the right side, for both traces.

So the hardware works pretty much the way it should.

Wheee-hooo!

Given that the motor current amounts to maybe 3 A, absolute maximum, with a locked rotor, those skinny wires on the slit ferrite toroid won’t pose a problem:

I really like how that 3D printed armor worked out, even if I still haven’t poured any goop around the windings to lock them down; they’re held in by raw faith and friction.

The current sense circuitry appears along the bottom of the AC Power Interface schematic:

The differential amplifier lives on the Low Voltage Interface board, forming the clump of parts just in front of the LM324 op amp on the left:

Which has the usual handful of components required to get anything done in the analog realm:

The power supplies come directly from the ATX connector. I’m ignoring the whole decoupling issue, because the supplies have essentially no load (and it’s all DC, anyway).

The trim pot sets the offset voltage to bring the Hall effect sensors’s V_CC/2 offset down close to zero; the 100 mV figure is nominal, not actual, but should be a bit over 0 V to allow for a wee bit o’ drift. This time around, I’ll measure and subtract the actual offset, rather than (try to) auto-zero it.

The voltage gain runs just under 3, set by 1% resistors from the heap. The overall gain works out to about 1.9 V/A or 525 mA/V, setting the high end at 5 V to a scant 2.6 A. Subject to actual calibration with more attention to detail, that’s close enough; we’re more interested in the around-an-amp range where the motor operates under nominal load.

The nose-to-tail Schottky diodes clamp the op amp output to avoid annoying the Arduino’s ADC input. It has protection circuitry, too, but there’s no point in stressing it.

Given that the GX270 case has a power pushbutton on the front panel, it seemed only reasonable to let it control the ATX power supply just like it used to. Most of the parts clumped in front of the panel’s ribbon cable handle that logic:

The pushbutton on the far left parallels the front-panel button so I don’t have to reach around the box just to turn it on.

The schematic shows the relevant bits:

The ATX +5 V Standby output remains turned on all the time, so I wired that to the power button’s yellow LED, to show that the plug is in the wall.

The pushbutton pulls the ATX Power_On line down, which turns on the supply outputs, which fires up the Arduino, which turns on the transistor, which holds the Power_On line down. D302 isolates the transistor from the button, so the code can sense the button’s on/off state with the power on. D303 isolates the Power_On line from the sense input to prevent the pullup on the Power_On line from back-powering the Arduino through its input protection diodes when the power is off.

The Arduino code starts by arranging the I/O states, turning the transistor on, pulsing the green power LED until until the button releases, then leaving the green LED on:

	pinMode(PIN_PWR_G,OUTPUT);
	digitalWrite(PIN_PWR_G,HIGH);				// visible on front panel

	pinMode(PIN_ENABLE_ATX,OUTPUT);				// hold ATX power supply on
	digitalWrite(PIN_ENABLE_ATX,HIGH);

	pinMode(PIN_ENABLE_AC,OUTPUT);				// turn on AC power
	digitalWrite(PIN_ENABLE_AC,HIGH);

	pinMode(PIN_BUTTON_SENSE,INPUT_PULLUP);		// wait for power button release
	while (LOW == digitalRead(PIN_BUTTON_SENSE)) {
		delay(50);
		TogglePin(PIN_PWR_G);					// show we have control
	}
	digitalWrite(PIN_PWR_G,HIGH);

Every time around the main loop, this chunk of code checks the button input:

	if (LOW == digitalRead(PIN_BUTTON_SENSE)) {
		printf("Shutting down!\r\n");
		digitalWrite(PIN_ENABLE_AC,LOW);
		digitalWrite(PIN_ENABLE_ATX,LOW);
		while(true) {
			delay(20);
			TogglePin(PIN_PWR_G);				// show we have shut down
		}
	}

The never-ending loop blinks the green LED until the power goes down, which happens when the button releases. That terminates the loop with extreme prejudice., which is the difference between embedded programming and high-falutin’ Webbish stuff.

And it Just Worked the first time I fired it up…