Toolpost Spindle, Part 2

I've mostly finished the toolpost spindle.

I found the perfect spindle motor on All Electronics, of all places, for $17.  It's a very cute brushless inrunner.  I dyno-ed it at 500 watts peak output at 48V, running of a 17A sensorless e-bike motor controller.  I forgot to take a picture of the inside, but the rotor has a thin steel sleeve around it, so the magnets won't fly off the rotor at high speed.  So I'm not worried about running it at 48V, even though it's nominally a 24V or so motor.

Unfortunately, none of my motor controllers are quite the right for this thing.  I wanted ~48 V, 10-20 amps, with hall sensor position feedback, and closed-loop speed control.  Fortunately, Charles and Bayley recently acquired a massive pile of mostly-not-working hoverboards.  The motor controllers in hoverboards pretty much exactly fit the bill.  They even do closed loop speed control with hall feedback!  I did a little investigation, and it seems like they run ST's motor library, doing dual-FOC on an STM32F103.  At low, speeds, they block-commutate, and at high speeds the phase currents become sinusoidal once they can interpolate between hall edges.

Phase current at low speed, scoped with the LEM-Stick:

Phase current at higher speed:

Fortunately, other people have figured out the serial protocol the hoverboard controllers use, so it was fairly straightforward to get it spinning the motor.

Unfotunately, the hall effect sensors in the All Electronics motor had very advanced timing, in the wrong direction for my application.  I opened up the motor, broke the glue holding down the hall sensor PCB, and reversed the timing:

I CNC milled an aluminum connector housing, for a DB25 connector.  Each phase has 6 parallel pins, plus 5 pins for hall sensors:  The steel front plate was made with a Bridgeport and hand files to match the motor curvature.  The 2-stepped HTD pulley was done on the CNC mill.

I made a height adjuster out of a chunk of steel.  I still need to make a nice thumbwheel for it.

I shoved a Nucleo and the hoverboard controller into the shell of an old G5 Mac Mini.  The power button on the left also came from a hoverboard, and I found an appropriately labeled knob to stick on the speed potentiometer:

Here it is mounted on the toolpost.  The spacing between the two pulleys is fixed, and I was able to choose the two sets of pulleys to have almost exactly the same center distances and belt lengths, so there's no need for a belt tensioner:

I've used it for a few jobs so far., including in-place drilling a bolt patterns into a big pulley and hub I turned, and also for deburring some internal ring gears:

Motor Dyno Efficiency Mapping

I finished up the code for automatically generating and post-processing efficiency maps on the motor dyno.  You give it a maximum speed, a maximum command vs speed, and number of points to sample in speed and command, and it auto-generates a time-stamped .csv file my dyno software can read.  Then the dyno plays back the time series, and logs the data.  To extract the points of interest, the log has a flag in it, which is set to 1 after each operating  point has settled, and 0 the rest of the time.  The post-processing script just finds all the intervals where the flag is 1, averages all the samples collected over that period, and combines them into one point.  So each point on the efficiency map is from several seconds of data.

Here's a video clip showing part of the process.  The motor being tested is a cheap knock-off of a Tiger Motor U8, at 22 volts, and 22 peak phase amps.

Here's the scatter plot of data points tested during the efficiency map:

And here's the data interpolated into a surface, in the classic efficiency map style:

I wouldn't read too much into the relatively low numbers (~74% peak efficiency), as this test was only at 22V and high peak current and these motors are good to spin much faster on more volts.

Also, some time soon I'm going to add a motor data page to the site, with whatever data I pull off the dyno on it, so keep your eye on the top bar.  I figure it might eventually be a useful resource, to have a page with lots of electric motor performance curves, efficiency maps, etc. on it.

EMRAX Motor Teardown

** 12/5/2017 Update **
A number of people noticed that this post disappeared for a while.  Here's why.  Skip down for the actual teardown

TL:DR, Emrax is a shitty company.  They seem to have no/poor protection of their IP, and are willing to bully college students to keep pictures of their motors off the internet.

On July 4, I received the following message through the contact form on this site, typos and all:

Dear Mr. Ben,
I am a representative of EMRAX company. We have come across your web site, where you have published disassembled EMRAX motor. We want you to removie this article. We are signing Non-disclosure agreement with every our customer. I believe that also Massachusetts Institute of Technology (MIT) has signed it. Consider this agreement and remobe the article as soon as possible. I am waiting for your reply.
If you have any further questions feel free to contact me.

Hmm, sounds fishy.  I don't buy it.  My response:

Me:

Hi, 
This particular motor was not purchased by myself or by MIT - it was donated to the MIT electric vehicle team by a company a number of years ago, and lent to me by the the electric vehicle team.  I do not believe that I am held to any agreement in the NDA signed by the original purchaser.

There was some more back-and-forth.

Emrax:

thank you for your reply. NDA is valid also for any third parties that are involved. Please remove the article as soon as possible.

Me:

You have not provided me with any evidence that I need to remove the article.  At the very least, could you send me a copy of the NDA?

Emrax:

sorry for delayed response. We have summer holidays there days, so only a few people are working now. I have forwarded this email to our Sales department. We will look into our archive of NDA-s, because it was written some time ago. We will also send it to MIT.
---
I have attached our “General Terms and Conditions” – they are also published on our web site. Please take a look at the Item 15 – Intellectual Property Rights. They are also published on our website.  Article should be removed as soon as possible.

Here's the General Terms and Conditions document.  Which not an NDA.

Me:

That is not a copy of the NDA.  14(c) in the "general terms and conditions" implies the NDA is a separate document.   

Furthermore, your "general terms" define "intellectual property rights" as:
"any patents, trademarks, registered designs and all applications for their registration, copyrights or design rights or any rights similar to these rights. " 

I do not believe that photographs of the inside of the motor qualify as your intellectual property.  I am not infringing upon any patents, copyrighted material, or trademarks of yours.

After this, I don't hear anything from Emrax for a while.  I'm pretty sure they have no legitimate claim for asking me to take down these pictures, and even if they did, I'm not sure how they would enforce them.

For a little while I thought I was done with this nonsense, but then I got an email from the captain of MIT's FSAE team, saying that they were trying to purchase a custom-wound motor from Emrax, but emrax was refusing to sell to them until I removed this post.

I sent this to Emrax:

I have just received word from the MIT FSAE team that you are withholding the sale of a motor to them until I remove the article, on the grounds that my pictures violate the NDA FSAE signed when they first purchased a motor from you.  I would like to reiterate that I am not and have never been affiliated with the MIT FSAE team, and the motor I took apart was not purchased by or ever used by MIT FSAE.   

Using MIT FSAE to bully me into removing the article is unfair to FSAE, and reflects quite poorly on you as a company.

Unsurprisingly, I didn't hear anything back from Emrax, but I did remove this post, because I didn't want to screw over the FSAE team.  While it seems Emrax has no actual legal grounds for making me remove these pictures, they do have the right to refuse to do business with someone.

Now FSAE has their custom Emrax motor, so I'm putting this back online, along with the story of how shitty Emrax is.  So if you or your friends are ever thinking about doing business with Emrax, beware.

************

And back to the teardown...

The EMRAX series of motors are some really impressive axial-flux motors, designed in Slovenia, for applications like ultralight aircraft.  Thanks to their absurd datasheet numbers, they seem to be the favorite choice of FSAE teams everywhere.

The particular model we took apart (228LV) turns out to be particularly miserable to control.  It's combination of ultra-low resistance (1.12 mΩ) and inductance (10 uH) means you would need to switch ~100 kHz at rated voltage, in order to have reasonable amounts of current ripple just from the PWM, which is kind of unreasonable for silicon MOSFETs or IGBT's of sufficient current and voltage rating.  So it's a great motor, but not very useful unless you can afford to build a GaN-FET or SiC-FET inverter for it.  Since CRC has two of these motors, Bayley and I decided it was worth the risk of disassembling one, to learn what magic-sauce goes on inside.

Here's the motor we started out with.  There was a layer of blue tape around the outside to stop metal shavings from getting inside the motor during bench-testing.  Like any good hobby-grade motor, the rotor and housing are full of holes for weight reduction and airflow.

After pulling off the stator of the resolver, we ran into this really obnoxious locknut, which was peened over into a keyway on the shaft to prevent you from removing it.  Fortunately, the steel isn't particularly hard, and a diamond-coated dremel grinding attachment made short work of the peened over bits.

Here's the rotor of the resolver.  The bolt on the left has a tapered head, so as you tighten it, it drives the split in the shaft apart, so it grips the inside of the motor shaft.

Next step was pulling the rotor.  This is always hairy business with axial flux motors, because of the huge magnetic forces holding the halves of the motor together.  In the past, this has been done at MITERS like this, but there ended up being a better way for this motor.  First, we pulled the set-screws along the outside if the rotor.

I drilled and tapped a 5/8" -11 thread into the end of the shaft that came with the motor, and used the bolt like a crank-extractor to pull the top half of the rotor away from the steel motor shaft.

Bolt all oiled-up and ready for cranking:

*Pop*

And, here's the magic-sauce revealed.....

wait a second, there isn't any magic-sauce.  This is pretty much exactly what I was expecting.  The motor has a YASA-style construction, with independent segments of steel lamination and winding, all fixed to an aluminum hub.

Everything on the inside is thoroughly doused in epoxy and some red stuff I've seen in other motors before but don't know the name of:

And here's the magnet array.  Each magnet is made from 3 sub-magnets, and they're epoxy coated rather than nickle-coated.  As an astute reader pointed out, this is to reduce the eddy current losses in the magnets (see YASA analysis).  Ease of assembly, maybe?  There's no halbach array, or any other magnetic fanciness going on, at least as far as I can tell.

Before taking the motor apart, I thought there might be a hallbach array, since the entire rotor appeared to be aluminum, but no flux seemed to leak out the back of the rotor.  However, scraping off some of the epoxy between the magnets, it looks like there is indeed some steel behind the magnets:

Zoomed in view.  I can't tell if those are actual laminations, or just coarsely-turned steel, but it definitely feels like steel.

And here's the fully exposed stator.

Both halves of the rotor had an "N" scratched into the anodizing by hand, presumably to help line up the magnets on the two halves of the rotor.

Here's the aluminum rotor-ring:

Happy motoring!

Encoder Autocalibration for Brushless Motors: Offset and Eccentricity

I finally got around to writing a position sensor auto-calibration procedure, for measuring the orientation of the position sensor relative to the stator.  Until now, I've been manually measuring that position by setting my U phase high, and V and W low to, lock the rotor to the D-axis, looking at the position sensor reading about a few of these points, and hard-coding them into my firmware.

This process should work regardless of the order the motor phases are plugged in to the controller, or how the position sensor is initially oriented.

Step 1:  Determine Phase Ordering

The purpose of this step is so that commanding positive current on the q-axis produces torque in the direction that causes the encoder angle to increase.  Basically, the process is to apply a large, slowly rotating current to a "virtual" D-axis.  The rotor will closely follow this rotation.  This is basically equivalent to driving the motor like a stepper motor with microstepping.  As the current rotates around, if the encoder count is increasing in the positive direction, then everything's good.  If the encoder count is decreasing, then swap the voltage outputs and current sensor inputs on two phases.  Now the motor will rotate the correct direction.

In pseudo-code:

v_d = 1;                                                            // Volts on the D-Axis
v_q = 0;
reference_angle = 0;                                                
start_angle = encoder.GetPosition();                                //starting position
while(reference_angle < 2*Pi){
    [v_u, v_v, v_w] = abc_transform(reference_angle, v_d, v_q, 0)   //inverse dq0 transform to get phase voltages
    wait();                                                         //give the rotor some time to settle into position
    reference_angle += .001;
    }
end_angle = encoder.GetPosition();                                  // final position
if(start_angle - end_angle > 0){                                    // if position decreased, swap phases
    swap_phases();                                                  
    }

Step 2:  Measure Encoder Offset

Now that the motor spins the right direction, you can measure the DC offset of the encoder.  Just like before, apply volts to the  D axis, and slowly rotate the axis through a whole mechanical rotation both backwards and forwards.

Looking at the position sensor output vs the reference angle, you'll see something like this.

Zooming in a bit, you can see some ripple in the tracking from cogging torque:

Looking at the error between the reference angle and the actual rotor angle, things get a little bit more confusing.  The error plot below has a few interesting features.

First, and most obviously, the mechanical offset of the encoder is just the average value of the error.  The electrical offset (which is what we actually care about for commutation) is just mod((mechanical error) * (number of pole pairs) , 2π). 

The high frequency ripple (which in this zoomed-out view looks almost like noise), is from the cogging torque (the ripple that showed up in the red trace above).  

Right in the middle of the plot, there's a jump downwards.  This is where the motor switches direction.  Since the motor has friction and inertia, it always lags slightly behind the reference angle, so that lag switches sides when the motor switches directions.  

Then there's some low-frequency, much larger ripple on top of the signal.  This is from eccentricity of the position sensing IC/its magnet.  In my case, it's because I accidentally messed up the design of a PCB and placed the IC 0.5 mm off to one side.  The total peak-to-peak height of this ripple is only around 0.03 radians, or 1.7 degrees, which doesn't sound like a lot.  However, I'm using a 21 pole-pair motor, which means that 1.7 degrees of mechanical error translates to 36 degrees of electrical error.  Enough to seriously throw off commutation.  The next step will go through how I corrected for the error from eccentricity.  While this won't be nearly as much of a problem once I get the new round of boards in, there will always be a little error in the placement of the IC (especially when they're hand-soldered by me), so having this feature is still definitely useful.

Step 3:  Eccentricity Correction

The first trick for correcting for the eccentricity is separating out the error from cogging and friction from the eccentricity error.  

Friction is easy.  Just average the samples rotating forwards with the samples rotating backwards.  Then plotting error you have something like this 

Removing the ripple from cogging torque took some more thought, but it turns out can be done extremely effectively.  My initial though was to just low-pass filter the signal, and hope that cogging could be sufficiently attenuated without changing the eccentricity part of the signal too much.  Honestly, for this particular motor with lots of pole-pairs and many cogging steps per electrical cycle, that would have probably worked just fine.  But you can do better, and make the result more easily applicable to other motors.

The trick is to take advantage some properties of motors and FIR filters.  Since the motor is rotationally symmetric, the frequency of the cogging ripple must be some integer multiple of the electrical frequency.  FIR filters can be designed such that they have zero gain at certain frequencies and harmonics of those frequencies.  So you can easily design a filter that has zero gain at the electrical frequency, and all multiples of it, nearly perfectly cancelling out the cogging ripple without affecting lower frequencies.  I'm using basically the simplest possible FIR filter - I just average n samples around the point of interest, and choose n such that the samples I'm averaging exactly span one electrical cycle.  This should work pretty well on any motor, as long as the number of pole pairs is larger than the highest harmonic from eccentricity.  Here's what the the filtered version of the signal looks like:

Now, with that filtered signal, you can build a lookup-table to correct the encoder output.  It doesn't even need to be particularly high-resolution, since the signal varies slowly - I'm using 128 points, and it works great.  The lookup table is generated by subtracting the average value off of the error, and then converting the error back into raw encoder counts.  I'm cheating a little bit and using the reference position as the x-axis, rather than the actual encoder value, because it's nice and evenly spaced into a grid already.  This approximation works quite well though. 

Here are three lookup tables generated independently, showing the consistency of this technique:

My latest round of motor control firmware can be found here, if you want to look through the autocalibration code.  It's fairly unpleasant to read, but it is well commented.  The code as a whole is very much a work in progress, so don't expect to put it on anything and have it work out-of-the-box.

At some point I'll throw a high-resolution optical encoder on the output to quantify the improvement in position error, but in terms of torque ripple, this process qualitatively improved things enormously.

Lathe Toolpost Spindle

I've been thinking for a while it would be nice to have live tooling for the MITERSlathe, for things like grinding and indexed drilling parts like hubs.

So far I've made everything out of random bits and pieces found at MITERS.  For the spindle, I started out with this old R8 to ER16 adapter:

I meticulously turned the shank down to 20mm.  I used sandpaper and Scotchbrite to bring the shaft to within a couple tenths down the whole length.

This was an incredibly satisfying measurement.

The bearings lightly press on the shaft - it's a tight enough fit that you just barely need an arbor press, but you can still easily un-press the bearings without damaging them.

Here's some of the housing machining.  I started out with this huge brick of mystery-steel I found on the floor of MITERS.  I got really lucky - it happened to be perfectly sized for machining a tool-holder,  and machined wonderfully.  It fly-cuts especially nicely, producing an incredibly shiny surface:

I squared up the block on the mill, cut the dovetail, and spot-drilled the spindle bore.

I did all the spindle boring on the lathe.  I started out by placing the housing on the toolpost, centering it vertically, and indicating the back face to be parallel to the travel of the lathe.  I put drills in the lathe's collet chuck, and use the lathe kind of like a horizontal  boring mill, to guarantee that the spindle bore was true to the  the lathe's travel:

To machine the bearing bores, I put the housing in the 4-jaw chuck and indicated in the drilled holes, as well as the faces, to make sure the housing was both square and centered.  I used this big indexable drill bit as a boring bar, because it has wonderfully sharp positive-rake inserts which produces a much better surface finish with low cutting pressure than the usual negative-rake turning inserts do.

I used a different bearing arrangement than I did with the tiny lathe, and I'm very satisfied with how it turned out.  I only had deep-groove ball  bearings to work with, rather than angular contact bearings, and I used a 3-bearing arrangement.  There's a pair of bearings at the front of the spindle, with a 0.002" shim between their inner races.  When the spindle housing is assembled, the outer races get squeezed together, so the shim provides a fixed preload.  This puts the bearings in a face-to-face arrangement, making the spindle somewhat tolerant to misalignment of the back bearing, if there is any.  The back bearing is a very close slip fit into the housing, and the outer race is lightly preloaded outwards by a wavy washer, to keep the balls in contact with both races.  Finally, there's a spacer between the inner races of the front and back bearings.  When the bolt on the back of the spindle is tightened, it squeezes down on the inner races and spacer, locking everything together.

Over all, I'm much happier with how this arrangement worked out compared to the lathe spindle.  Since preload is fixed, it takes no fussing to get the spindle to spin smoothly without slop, assuming the shim is sized correctly.  Also, since the front bearings are so close together, the preload will hardly change as the spindle heats up and expands.  For the lathe, I left the spindle on for a while, and pre-loaded the bearings with the spindle at normal operating temperature.

A plate on the front of the housing presses the outer races of the bearings together, to preload the bearings:

To test it out, I threw a Lovejoy coupling on the back, and a mating one on the output shaft of an old orbital sander motor, which was roughly appropriate speed.  Conclusion:  the spindle part works great, and, unsurprisingly, the orbital sander motor was terrible.  Needs more brushless servo.

Here are the two mounting configurations.  I tested it out with a 3/8" endmill, and the spindle was rock solid, producing an excellent surface finish without any signs of chattering.

Still to do:
- Find a better spindle motor, and make a motor attachment and height stop.
- Make an indexing system for the lathe spindle, so you can precisely lock the spindle to certain angles.