30:T4ea,# DESI Linear Phi Operation Use the controls below to visualize the behavior of a linear-phi motor. Enter a sequence of signed angles to move and specify if the initial move is a direction change (so backlash needs to be taken out). The linear phi behavior is governed by 4 parameters: the true CW and CCW scale factors for cruising and ramping. The ramp scale factors specify the fraction of the nominal combined ramp up and down (${d3.format("0.3f")(nominalRampDeg)}° for ${motorConfigString}) that the motor actually moves through. The move table translation algorithm is governed by 2 separate parameters used to scale up the nominal number of cruise steps in each direction. When the applied and true cruise scale factors for each direction are equal and the ramp scale factors are also equal to each other. The actual motion equals the requested motion (up to round off errors in converting angles to integer cruise steps). When the CW and CCW ramp scale factors are different, the actual motion can over- or under-shoot the request. The shading below identifies the phases of a move: ramp up (yellow), cruise (green), ramp down (orange). Cross-hatching indicates times when the final stage of the planetary gears is disengaged to take up backlash.31:T405,viewof options = { const eps = 2.0; return Inputs.form({ anglesText: Inputs.text({label:"Angles", value:"-5,10", placeholder: "comma separated values", submit: true}), changeDir: Inputs.toggle({label: "Initial Dir Change?", value: true}), backlash: Inputs.range([0,2], { value: 1.2, step: 0.1, label: "Backlash [deg]" }), appliedCruiseScaleCW: Inputs.range([0.1,1], { label: "Applied Cruise Scale CW", value: 1, step:0.01 }), appliedCruiseScaleCCW: Inputs.range([0.1,1], { label: "Applied Cruise Scale CCW", value: 1, step:0.01 }), S: Inputs.range([0.1,1], { label: "True Average Scale", value: 1, step:0.01 }), dS: Inputs.range([-eps,eps], { label: "Cruise-Ramp Offset", value: 0, step:0.01 }), dC: Inputs.range([-eps,eps], { label: "Cruise CCW-CW Offset", value: 0, step:0.01 }), dR: Inputs.range([-eps,eps], { label: "Ramp CCW-CW Offset", value: 0, step:0.01 }), motorConfig: Inputs.radio(motorConfigs, {label: "Motor Config", value: motorConfigs.get("Set3")}), }); }32:T5c6,class LinearPhiModel { constructor( appliedCruiseScaleCW, appliedCruiseScaleCCW, {cruiseStep=100, upRamp=1, downRamp=1, backlash=1.2, gearRatio=(46 / 14 + 1) ** 4}={}) { Object.assign(this, {appliedCruiseScaleCW, appliedCruiseScaleCCW, cruiseStep, backlash, gearRatio}); // Compute total number of ramp up and down steps during a cruise move. function ramp(spinStep) { return [].concat(...d3.range(cruiseStep + 1).map(n => new Array(spinStep).fill(n))); } const spinUp = ramp(upRamp), spinDown = ramp(downRamp).reverse(); this.nominalRampSteps = d3.sum(spinUp) + d3.sum(spinDown); } actualAngle(requestedAngle, trueCruiseScaleCW, trueCruiseScaleCCW) { // Is this move CW or CCW? const [ reqSign, appliedCruiseScale , trueCruiseScale ] = (requestedAngle >= 0) ? [ +1, this.appliedCruiseScaleCCW, trueCruiseScaleCCW ] : [ -1, this.appliedCruiseScaleCW, trueCruiseScaleCW ]; // Calculate actual move. const nominalCruiseTicks = Math.round( (reqSign * requestedAngle * this.gearRatio * 10 - this.nominalRampSteps) / this.cruiseStep); const actualCruiseTicks = Math.round(nominalCruiseTicks / appliedCruiseScale); const disengagedDeg = reqSign * this.backlash; const trueRampScale = (trueCruiseScaleCW + trueCruiseScaleCCW) / 2; return reqSign / (10 * this.gearRatio) * ( trueRampScale * this.nominalRampSteps + trueCruiseScale * actualCruiseTicks * this.cruiseStep) - disengagedDeg; } }33:Tdcb,function cruise(outputAngles, { motorConfig=motorConfigs.get("Set3"), backlash=1.2, changeDir=true, initialAngle=0, S=1, dS=0, dC=0, dR=0, appliedCruiseScaleCW=1, appliedCruiseScaleCCW=1 }={}) { const {round, abs, sign, max} = Math; const {cruiseStep, upRamp, downRamp} = motorConfig; const spinUp = ramp(cruiseStep, upRamp); const spinDown = ramp(cruiseStep, downRamp).reverse(); const totalRamp = d3.sum(spinUp) + d3.sum(spinDown); let lastSign = null, lastAngle = initialAngle; const omega = [ ], angle = [ ], disengaged = [ ], rampingUp = [ ], rampingDown = [ ], cruising = [ ], table = [ ]; outputAngles = outputAngles instanceof Array ? outputAngles : [ outputAngles ]; for(const request of outputAngles) { const reqSign = sign(request); const appliedCruiseScale = reqSign > 0 ? appliedCruiseScaleCCW : appliedCruiseScaleCW; const { trueCruiseScale, trueRampScale } = getMotorParams(reqSign, { S, dS, dC, dR }); // Calculate the nominal number of cruise ticks for this request const nominalCruiseTicks = round((reqSign * request * gearRatio * 10 - totalRamp) / cruiseStep); if(nominalCruiseTicks < 0) throw new Error( `requested ${request}° < total ramp of ${d3.format(".2f")(totalRamp/10/gearRatio)}° at ${cruiseStep}-${upRamp}-${downRamp}`); // Calculate the actual number of cruise ticks after move table conversion. const actualCruiseTicks = round(nominalCruiseTicks / appliedCruiseScale); if(actualCruiseTicks > 0) { const start = omega.length + spinUp.length; cruising.push({ start, stop: start + actualCruiseTicks}); } // Generate the actual cruise motor output, with scale factor applied. const cruise = new Array(actualCruiseTicks).fill(cruiseStep * trueCruiseScale); // Generate the actual ramp motor output, with scale factor applied. const up = spinUp.map(omega => omega * trueRampScale); const down = spinDown.map(omega => omega * trueRampScale); // Combine the ramps and cruise to calculate the signed motor angular speed. const reqOmega = [].concat(up, cruise, down).map(omega => omega * reqSign); rampingUp.push({ start: omega.length, stop: omega.length + spinUp.length }); rampingDown.push({ start: omega.length + reqOmega.length - spinDown.length, stop: omega.length + reqOmega.length }); // Integrate steps to calculate the angular motion. let reqAngle = toAngle(reqOmega); // Did we change direction? changeDir = lastSign == null ? changeDir : (lastSign * reqSign < 0); lastSign = reqSign; if(changeDir) { // Take up backlash. reqAngle = reqAngle.map(angle => reqSign * max(0, reqSign * angle - backlash)); const disengagedTicks = reqAngle.filter(angle => angle == 0).length; if(disengagedTicks > 0) { disengaged.push({start: omega.length, stop: omega.length + disengagedTicks}); } } // Combine with any previous requests. omega.push(...reqOmega); angle.push(...reqAngle.map(angle => angle + lastAngle)); lastAngle = angle[angle.length - 1]; // Update the summary table. const elapsedMS = 1e3 * angle.length / clockSpeed; table.push({ requestDeg:request, actualDeg: reqAngle[reqAngle.length-1], netDeg: angle[angle.length-1], elapsedMS, nominalCruiseTicks, actualCruiseTicks }); } const time = d3.range(omega.length); const steps = tidy({ time, omega, angle }); return { steps, table, rampingUp, rampingDown, cruising, disengaged }; }34:T19ed,// Based on https://observablehq.com/@tomshanley/cheysson-color-palettes patterns = () => svg` `35:[] 2e:{"title":"DESI Linear Phi Operation","cells":[{"id":0,"value":"$30","pinned":false,"hidden":false,"mode":"md"},{"id":129,"value":"$31","pinned":false,"hidden":false,"mode":"ojs"},{"id":13,"value":"{\n const {steps, rampingUp, rampingDown, cruising, disengaged } = motion;\n return Plot.plot({\n marks: [\n patterns,\n Plot.ruleY([0], { stroke: \"gray\", strokeDasharray: [4, 4] }),\n Plot.line(steps, {x:\"time\", y:\"angle\"}),\n Plot.rectX(rampingUp, {x1:\"start\", x2:\"stop\", fill:\"yellow\", fillOpacity: 0.3}),\n Plot.rectX(rampingDown, {x1:\"start\", x2:\"stop\", fill:\"orange\", fillOpacity: 0.2}),\n Plot.rectX(cruising, {x1:\"start\", x2:\"stop\", fill:\"green\", fillOpacity: 0.2}),\n Plot.rectX(disengaged, {x1:\"start\", x2:\"stop\", fill:\"url(#grouped-12512014-2)\", fillOpacity:0.2}),\n ]\n });\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":211,"value":"Inputs.table(motion.table)","pinned":false,"hidden":false,"mode":"ojs"},{"id":293,"value":"Chose true scale parameters so there is a hierarchy ${tex`S, \\Delta C, \\Delta R, \\Delta S`} from best-measured to least-well measured:\n${tex.block`\n\\begin{aligned}\nC_{-} &= S + \\Delta S - \\Delta C \\\\\nC_{+} &= S + \\Delta S + \\Delta C \\\\\nR_{-} &= S - \\Delta S - \\Delta R \\\\\nR_{+} &= S - \\Delta S + \\Delta R \\\\\n\\end{aligned}\n`}\nwhere ${tex`C`} and ${tex`R`} refer to cruise and ramp scale factors, respectively, and ${tex`\\pm`} refer to CW(${tex`-`}) or CCW(${tex`+`}). The ${tex`\\Delta`} parameters are generally near zero and the signs are chosen so that positive values are more likely.","pinned":false,"hidden":false,"mode":"md"},{"id":10,"value":"---","pinned":false,"hidden":false,"mode":"md"},{"id":414,"value":"$32","pinned":false,"hidden":false,"mode":"ojs"},{"id":234,"value":"function actualAngle(requestedAngle, parameters) {\n const {round} = Math;\n const {motorConfig} = options;\n const {cruiseStep, upRamp, downRamp} = motorConfig;\n const {backlash, changeDir, appliedCruiseScaleCW, appliedCruiseScaleCCW} = parameters;\n const reqSign = Math.sign(requestedAngle);\n const reqDir = (1 + reqSign) / 2;\n const appliedCruiseScale = reqDir * appliedCruiseScaleCCW + (1 - reqDir) * appliedCruiseScaleCW;\n const {trueCruiseScale,trueRampScale} = getMotorParams(reqSign, parameters);\n const nominalCruiseTicks = round((reqSign * requestedAngle * gearRatio * 10 - nominalRampSteps) / cruiseStep);\n const actualCruiseTicks = round(nominalCruiseTicks / appliedCruiseScale);\n const disengagedDeg = reqSign * (changeDir + 0) * backlash;\n return reqSign / (10 * gearRatio) * (\n trueRampScale * nominalRampSteps + trueCruiseScale * actualCruiseTicks * cruiseStep) - disengagedDeg;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":207,"value":"motion = {\n const angles = options.anglesText.split(\",\").map(x => 1*x);\n return cruise(angles, options);\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":251,"value":"nominalRampDeg = nominalRampSteps / (10 * gearRatio)","pinned":false,"hidden":false,"mode":"ojs"},{"id":225,"value":"nominalRampSteps = {\n const {motorConfig} = options;\n const {cruiseStep, upRamp, downRamp} = motorConfig;\n const spinUp = ramp(cruiseStep, upRamp);\n const spinDown = ramp(cruiseStep, downRamp).reverse();\n return d3.sum(spinUp) + d3.sum(spinDown);\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":236,"value":"motorConfigString = {\n const {motorConfig} = options;\n const {cruiseStep, upRamp, downRamp} = motorConfig;\n return `${cruiseStep}-${upRamp}-${downRamp}`; \n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":5,"value":"$33","pinned":false,"hidden":false,"mode":"ojs"},{"id":318,"value":"function getMotorParams(reqSign, fitParams) {\n const {S, dS, dC, dR} = fitParams;\n return { trueCruiseScale: S + dS + reqSign * dC, trueRampScale: S - dS + reqSign * dR };\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":41,"value":"motorConfigs = new Map([\n [\"Nominal\", {cruiseStep: 33, upRamp:12, downRamp:12}],\n [\"Set1\", {cruiseStep: 66, upRamp:2, downRamp:3}],\n [\"Set2\", {cruiseStep: 82, upRamp:2, downRamp:2}],\n [\"Set3\", {cruiseStep: 100, upRamp:1, downRamp:1}],\n])","pinned":false,"hidden":false,"mode":"ojs"},{"id":31,"value":"toRPM = omega => omega.map(w => w * clockSpeed / 10 / 360 * 60)","pinned":false,"hidden":false,"mode":"ojs"},{"id":29,"value":"toAngle = omega => new Array(...d3.cumsum(omega)).map(a => a / 10 / gearRatio)","pinned":false,"hidden":false,"mode":"ojs"},{"id":27,"value":"function ramp(cruiseStep, spinStep) {\n return [].concat(...d3.range(cruiseStep + 1).map(n => new Array(spinStep).fill(n)));\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":23,"value":"clockSpeed = 18000 // Hertz","pinned":false,"hidden":false,"mode":"ojs"},{"id":25,"value":"gearRatio = (46 / 14 + 1) ** 4","pinned":false,"hidden":false,"mode":"ojs"},{"id":86,"value":"import {tidy} from \"@dkirkby/array-utilities\"","pinned":false,"hidden":false,"mode":"ojs"},{"id":101,"value":"$34","pinned":false,"hidden":false,"mode":"ojs"}],"files":"$W35","stdlib":"1","titling":"auto"}