31:T42a,You can see two LEDs on this side of the wheel, and there are two sensors on the opposite side. As the wheel turns, the gratings in the wheel shadow the sensors from the LED light. They're spaced so that the shadows happen at different times, about 90 degrees out of phase. (Here are the CAD drawings for [the wheel](https://cad.onshape.com/documents/f7b53cde09e251b518cccd62/w/06b6b14718d8f905d7cff9ac/e/144c61500b925644eb7d42e8?renderMode=0&uiState=6286e46fd430963df41bba0c) and the [LED and phototransistor holders](https://cad.onshape.com/documents/8beb0f05707f7f5f2a49ec8f/w/bb5c6daf7bb98871870d143c/e/d65347634acc1c83b46b3ae3?renderMode=0&uiState=6286e0de6baec34f0bc4b2be), which I 3D printed.) To do this experiment, I slowly picked up the lever and lowered it again. A program running on a Raspberry Pi Pico recorded the voltages once every 2 milliseconds, using the microcontroller's built-in ADC. Then it prints them to the serial port, where they are recorded in [SerialViz](https://serialviz.skybrian.com/), a web app I wrote. Here is the recorded data:32:[{"id":"fcada4da5410450787c606663443e0bd11143a06dc0427a99bfc40e73e89cac755683318250ecf236262f1cfac2dcfaaea5384196c7ccdf6201bdb8ce3b1c3cb","href":"https://static.observableusercontent.com/files/fcada4da5410450787c606663443e0bd11143a06dc0427a99bfc40e73e89cac755683318250ecf236262f1cfac2dcfaaea5384196c7ccdf6201bdb8ce3b1c3cb","name":"sine_cos_encoder_test_4236rows.csv","type":"text/csv","lastModified":1652935499368.744,"size":31302},{"id":"8c5773fb7128ddbc29393968f5c1f6673acf76410ac90eb240eddf8268138f922af33b9252aefed44b47d2c8dfe1a48a0b37e2bd18df4562f1a452d161d5dde4","href":"https://static.observableusercontent.com/files/8c5773fb7128ddbc29393968f5c1f6673acf76410ac90eb240eddf8268138f922af33b9252aefed44b47d2c8dfe1a48a0b37e2bd18df4562f1a452d161d5dde4","name":"PXL_20220520_002029758.jpg","type":"image/jpeg","lastModified":1653006212140.641,"size":2107501}] 2f:{"title":"A Sine-Cosine Encoder Experiment","cells":[{"id":0,"value":"# A Sine-Cosine Encoder Experiment\n\nI'd like to find a good way to measure how fast a wheel is turning when it's moving slowly. In this experiment, I used two phototransistors to measure the light passing through an encoder wheel. Here's what it looks like:","pinned":false,"hidden":false,"mode":"md"},{"id":369,"value":"pxl_20220520_002029758 = FileAttachment(\"PXL_20220520_002029758.jpg\").image()","pinned":false,"hidden":false,"mode":"ojs"},{"id":372,"value":"$31","pinned":false,"hidden":false,"mode":"md"},{"id":3,"value":"## Sensor data","pinned":false,"hidden":false,"mode":"md"},{"id":21,"value":"Plot.plot({\n width: 1000,\n x: { label: \"samples\" },\n y: { label: \"ADC reading\", nice: true },\n marks: [\n Plot.lineY(left, {stroke: \"blue\"}),\n Plot.lineY(right, {stroke: \"green\"})\n ],\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":362,"value":"A low number means that the phototransistor is in shadow and a high number means that it's lit up. By counting the peaks on the blue line, you can see that the wheel rotated the sensor past about five holes in the grating before turning around.\n\nAlso, one LED seems to be brighter than the other. To adjust for that, I normalized the data so that the midpoint is zero and they have the same amplitude:","pinned":false,"hidden":false,"mode":"md"},{"id":59,"value":"## Normalized Data","pinned":false,"hidden":false,"mode":"md"},{"id":65,"value":"Plot.plot({\n width: 1000,\n x: { label: \"samples\" },\n y: { ticks: 2, domain: [-1.1, 1.1] },\n marks: [\n Plot.ruleY([0]),\n Plot.lineY(leftNormalized, {stroke: \"blue\"}),\n Plot.lineY(rightNormalized, {stroke: \"green\"})\n ],\n});","pinned":false,"hidden":false,"mode":"ojs"},{"id":134,"value":"Ideally, these signals would look like sine and cosine waves, but they look a bit distorted. Some of that might be because I rotated the wheel by hand and it was a little uneven. Let's plot the data a different way to see how circular it is:\n\n## X-Y plot","pinned":false,"hidden":false,"mode":"md"},{"id":144,"value":"Plot.plot({\n width: 640,\n height: 600,\n x: {\n ticks: 2,\n },\n y: {\n ticks: 2,\n nice: true\n },\n color: {\n scheme: \"turbo\",\n legend: true\n },\n marks: [\n Plot.ruleX([0]),\n Plot.ruleY([0]),\n Plot.line([[-1,-1], [1, 1]], {x: d => d[0], y: d=> d[1], stroke: \"grey\"}),\n Plot.line(xy, {x: \"x\", y: \"y\", z: null, stroke: (d, i) => i}),\n ],\n});","pinned":false,"hidden":false,"mode":"ojs"},{"id":166,"value":"Here's how to interpret this plot: the lower left corresponds to both sensors shadowed, and the upper right to both sensors lit. The opposite corners are when one sensor is lit and the other in shadow.\n\nWe can see that the sensors are never fully on or off at the same time, which is good. The curve is somewhat symmetric along the diagonal X=Y axis, but not entirely. Each sensor remains dark for a rather long time while the other sensor is ramping up or down. Maybe the holes exposing the sensors to light aren't quite right?\n\nThere might be ways to adjust for this, but for now I'll ignore the issue and go on. Even though the output isn't circular, we can still try measuring the phase using these signals.","pinned":false,"hidden":false,"mode":"md"},{"id":409,"value":"## Phase of the signal, visualized as a spiral","pinned":false,"hidden":false,"mode":"md"},{"id":175,"value":"{\n const scaleBySample = (val, sample) => val * (sample+500) / 1000;\n const spiral = xyNormalized.map((d,i) => ({x: scaleBySample(d.x, i), y: scaleBySample(d.y, i)}));\n \n return Plot.plot({\n width: 640,\n height: 600,\n color: {\n scheme: \"turbo\",\n legend: true\n },\n x: {\n axis: null,\n },\n y: {\n axis: null,\n },\n marks: [\n Plot.line(spiral, {x: \"x\", y: \"y\", z: null, stroke: (d, i) => i}),\n Plot.dot(spiral, {filter: (d,i) => i % 500 == 0, x: \"x\", y: \"y\", z: null, fill: \"currentColor\"}),\n Plot.text(spiral, {filter: (d,i) => i % 500 == 0, x: \"x\", y: \"y\", text: (d, i) => i, dy: -10})\n ],\n });\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":430,"value":"To make this plot, I changed the radius for each sample to something else, while preserving the angle (phase) of the signal. The distance to the origin now indicates the time that the sample was taken.\n\nYou can see that the signal rotates five times around the center before turning around and going the other way five times, ending up at about the same angle where it started.\n\n(Be careful not to confuse this with a wheel rotation. The wheel only rotated slightly. Each rotation on this graph corresponds to moving past one hole in the wheel's grating. The lower left corner still corresponds to both sensors in partial shadow.)","pinned":false,"hidden":false,"mode":"md"},{"id":206,"value":"## Angular Velocity","pinned":false,"hidden":false,"mode":"md"},{"id":544,"value":"This calculation determines how much the phase of the signal has changed, compared to a previous sample:","pinned":false,"hidden":false,"mode":"md"},{"id":529,"value":"angleDifference = (a, b) => { \n const dot = a.x * a.x + b.y * b.y;\n const cross = a.x * b.y - a.y * b.x; \n return Math.atan2(cross, dot) / (2 * Math.PI); \n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":562,"value":"Plotting this gives us a graph of the wheel's velocity:","pinned":false,"hidden":false,"mode":"md"},{"id":212,"value":"Plot.plot({\n width: 1000,\n x: {\n label: \"samples\"\n },\n y: {\n label: \"cycles\"\n },\n marks: [\n Plot.ruleY([0]),\n Plot.lineY(velocity, {y: d => d, stroke: \"#cce\"}),\n Plot.line(velocity, Plot.windowY({x: (d, i) => i, y: d => d, k: 15, reduce: \"mean\", anchor: \"end\"})),\n ],\n});","pinned":false,"hidden":false,"mode":"ojs"},{"id":437,"value":"Unfortunately, it's very noisy. (I also plotted a moving average, which smooths it out a bit.) But you can see that the wheel is stopped to begin with, rotates in one direction, then turns around and rotates in the other direction, finally coming to a stop. \n\nOne reason for the noise is because taking the derivative of a signal is equivalent to a high-pass filter. That's not the only problem though; the input signal not actually being circular might have something to do with these humps?\n\nLet's compare them to the original signal:\n\n","pinned":false,"hidden":false,"mode":"md"},{"id":880,"value":"{\n const start = 400;\n let zoomed = Array(zoom);\n for (let i = 0; i < zoomed.length; i++) {\n const {x, y} = xyNormalized[i + start];\n zoomed[i] = {sample: i + start, velocity: velocity[i + start], x: x, y: y};\n }\n \n const top = Plot.plot({\n width: 1000,\n height: 200,\n x: {\n label: \"samples\"\n },\n y: {\n label: \"cycles\"\n },\n marks: [\n Plot.ruleY([0]),\n Plot.line(zoomed, {x: \"sample\", y: \"velocity\", stroke: \"#cce\"}),\n Plot.line(zoomed, Plot.windowY({x: \"sample\", y: \"velocity\", k: 15, reduce: \"mean\", anchor: \"end\"})),\n ],\n });\n\n const bottom = Plot.plot({\n width: 1000,\n height: 200,\n x: { label: \"samples\" },\n y: { ticks: 2, domain: [-1.1, 1.1] },\n marks: [\n Plot.ruleY([0]),\n Plot.line(zoomed, {x: \"sample\", y: \"x\", stroke: \"blue\"}),\n Plot.line(zoomed, {x: \"sample\", y: \"y\", stroke: \"green\"})\n ],\n });\n\n return html`

${top}${bottom}

`;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":954,"value":"viewof zoom = Inputs.range([100, 1000], {value: 500, step: 10, label: \"Zoom\"})","pinned":false,"hidden":false,"mode":"ojs"},{"id":922,"value":"The humps in measured velocity do seem to correspond to particular points in a cycle. For example, the peak of the green line is usually slightly after a peak in velocity.","pinned":false,"hidden":false,"mode":"md"},{"id":107,"value":"## Phase of the signal, now as a regular graph","pinned":false,"hidden":false,"mode":"md"},{"id":113,"value":"Plot.plot({\n width: 1000,\n grid: true,\n x: {\n label: \"samples\",\n },\n y: {\n label: \"cycles\",\n nice: true,\n },\n marks: [\n Plot.lineY(rotations, {x: (d, i) => i})\n ],\n});","pinned":false,"hidden":false,"mode":"ojs"},{"id":513,"value":"If we integrate the angular velocity, we get back the phase, which is a little bumpy but doesn't look as bad, even though it's the same information. (Integration is similar to a low-pass filter.) This graph shows the distance the wheel travelled, measured in gratings. I turned the wheel five gratings before turning it back.\n\n(Another way to find the phase would be to calculate it directly using an [atan2 function](https://en.wikipedia.org/wiki/Atan2). This avoids any roundoff error. However, the range of atan2 is only one turn, so we'd also need to count rotations separately and adjust the output.)","pinned":false,"hidden":false,"mode":"md"},{"id":521,"value":"## Let's do it again with quadrature encoding\n\nInstead of using the ADC, I could have connected the phototransistors to digital pins. Then the signal would have looked something like this:","pinned":false,"hidden":false,"mode":"md"},{"id":597,"value":"{\n const tidy = xyDigitized.flatMap(({x, y}, i) => [{signal: \"x\", sample: i, val: x}, {signal: \"y\", sample: i, val: y}]);\n return Plot.plot({\n height: 300,\n width: 1000,\n facet: {\n data: tidy,\n y: \"signal\"\n },\n y: {\n ticks: 1,\n domain: [-0.2, 1.2],\n },\n fy: {\n axis: \"left\",\n },\n marks: [\n Plot.line(tidy, {x: \"sample\", y: \"val\", stroke: d => d.signal == \"x\" ? \"blue\" : \"green\"}),\n ],\n })\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":635,"value":"We still have five peaks in each direction, corresponding to the wheel moving past five holes in the grating. If we do an XY plot like we did with the analog signal, we get a square:\n","pinned":false,"hidden":false,"mode":"md"},{"id":697,"value":"Plot.plot({\n height: 280,\n width: 300,\n x: {\n ticks: 3,\n domain: [-1.1, 1.1],\n },\n y: {\n ticks: 3,\n domain: [-1.1, 1.1],\n },\n color: {\n scheme: \"turbo\",\n },\n marks: [\n Plot.ruleX([0]),\n Plot.ruleY([0]),\n Plot.line(centerXY(xyDigitized), {x: \"x\", y: \"y\", z: null, stroke: (d, i) => i})\n ],\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":715,"value":"Plotting this as a spiral lets us see the rotations:","pinned":false,"hidden":false,"mode":"md"},{"id":739,"value":"{\n const scaleBySample = (val, sample) => val * (sample+500) / 1000;\n const spiral = centerXY(xyDigitized).map((d,i) => ({x: scaleBySample(d.x, i), y: scaleBySample(d.y, i)}));\n \n return Plot.plot({\n width: 320,\n height: 300,\n color: {\n scheme: \"turbo\",\n legend: true\n },\n x: {\n axis: null,\n },\n y: {\n axis: null,\n },\n marks: [\n Plot.line(spiral, {x: \"x\", y: \"y\", z: null, stroke: (d, i) => i}),\n ],\n });\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":686,"value":"As before, the lower left corner means both lights are shadowed and the upper right means they're both lit up.\n\nBut the normal way to handle quadrature encoding is to interpret the two inputs as a single number:","pinned":false,"hidden":false,"mode":"md"},{"id":648,"value":"Plot.plot({\n height: 200,\n width: 1000,\n x: {\n label: \"sample\",\n },\n y: {\n label: \"code\",\n ticks: 4,\n },\n marks: [\n Plot.lineY(quadrature)\n ]\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":665,"value":"This code is a quantized measurement of the signal's phase. Here '0' is both sensors shadowed and '2' is both sensors lit. Counting up means that the wheel is rotating in one direction and counting down means it's going the opposite way.\n\nThe phase doesn't give us distance directly because it's using modular arithmetic, like a clock. We can fix that by finding the transitions:","pinned":false,"hidden":false,"mode":"md"},{"id":771,"value":"Plot.plot({\n width: 1000,\n height: 200,\n x: {\n label: \"samples\",\n },\n y: {\n label: \"cycles\",\n ticks: 3,\n domain: [-.4, .4],\n },\n marks: [\n Plot.lineY(ticks)\n ]\n});","pinned":false,"hidden":false,"mode":"ojs"},{"id":786,"value":"This is the angular velocity in the digital domain. A +0.25 tick means to rotate a quarter turn forward and a -0.25 tick means to rotate a quarter turn backward.\n\nIf we integrate this we get the phase, except not using modular arithmetic. Let's compare that to the analog version:","pinned":false,"hidden":false,"mode":"md"},{"id":834,"value":"Plot.plot({\n width: 1000,\n x: { label: \"samples\", },\n y: { label: \"cycles\", nice: true },\n marks: [\n Plot.lineY(rotations, {stroke: \"#88f\"}),\n Plot.lineY(digitizedRotations)\n ],\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":854,"value":"The digitized signal lags the analog signal going up and drops earlier going down, indicating that the number of cycles is being rounded down. (There might also be some accumulated roundoff error in the analog signal.)","pinned":false,"hidden":false,"mode":"md"},{"id":959,"value":"## Conclusions\n\n* Even with some flaws in the signals, there doesn't seem to be any advantage to quadrature encoding, so I'll keep using the ADC.\n\n* Experimenting with improving the geometry (like changing the shape of the holes in the sensor shades) seems worthwhile.\n\n* It would be good to compare the output with another way of measuring how much the wheel turned.","pinned":false,"hidden":false,"mode":"md"},{"id":17,"value":"## Appendix","pinned":false,"hidden":false,"mode":"md"},{"id":14,"value":"csv = FileAttachment(\"sine_cos_encoder_test_4236rows.csv\").csv({typed: true})","pinned":true,"hidden":false,"mode":"ojs"},{"id":37,"value":"left = csv.map((r) => r['Left V'])","pinned":false,"hidden":false,"mode":"ojs"},{"id":51,"value":"leftNormalized = center(left)","pinned":false,"hidden":false,"mode":"ojs"},{"id":40,"value":"right = csv.map((r) => r['Right V'])","pinned":false,"hidden":false,"mode":"ojs"},{"id":53,"value":"rightNormalized = center(right)","pinned":false,"hidden":false,"mode":"ojs"},{"id":156,"value":"xy = zipXY(leftNormalized, rightNormalized);","pinned":false,"hidden":false,"mode":"ojs"},{"id":170,"value":"xyNormalized = normalizeRadius(xy)","pinned":false,"hidden":false,"mode":"ojs"},{"id":199,"value":"velocity = angularVelocity(xyNormalized);","pinned":false,"hidden":false,"mode":"ojs"},{"id":104,"value":"rotations = {\n const out = Array(velocity.length);\n let sum = 0;\n for (let i = 0; i < out.length; i++) {\n sum += velocity[i];\n out[i] = sum;\n }\n return out;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":593,"value":"xyDigitized = zipXY(digitize(leftNormalized), digitize(rightNormalized));","pinned":false,"hidden":false,"mode":"ojs"},{"id":641,"value":"quadrature = xyDigitized.map(({x, y}) => { switch (`${x}${y}`) {\n case '00': return 0;\n case '10': return 1;\n case '11': return 2;\n case '01': return 3;\n}})","pinned":false,"hidden":false,"mode":"ojs"},{"id":767,"value":"ticks = {\n const out = Array(quadrature.length);\n out[0] = 0;\n for (let i = 1; i < out.length; i++) {\n const diff = quadrature[i] - quadrature[i-1];\n switch (diff) {\n case 0:\n out[i] = 0;\n break;\n case 1:\n case -3:\n out[i] = .25;\n break;\n case 3:\n case -1:\n out[i] = -.25;\n break;\n default:\n out[i] = NaN;\n }\n }\n return out;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":832,"value":"digitizedRotations = integrate(ticks)","pinned":false,"hidden":false,"mode":"ojs"},{"id":45,"value":"sum = (arr) => arr.reduce((sum, v) => sum + v, 0);","pinned":true,"hidden":false,"mode":"ojs"},{"id":49,"value":"average = (arr) => sum(arr) / arr.length","pinned":true,"hidden":false,"mode":"ojs"},{"id":73,"value":"max = (arr) => arr.reduce((max, v) => v > max ? v : max, -Infinity)","pinned":true,"hidden":false,"mode":"ojs"},{"id":77,"value":"min = (arr) => arr.reduce((min, v) => v < min ? v : min, Infinity)","pinned":true,"hidden":false,"mode":"ojs"},{"id":79,"value":"middle = (arr) => (max(arr) + min(arr)) / 2","pinned":true,"hidden":false,"mode":"ojs"},{"id":85,"value":"height = (arr) => max(arr) - min(arr)","pinned":true,"hidden":false,"mode":"ojs"},{"id":90,"value":"center = (arr) => {\n const mid = middle(arr);\n const scale = 2 / height(arr);\n return arr.map((v) => (v - mid) * scale);\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":149,"value":"zipXY = (left, right) => {\n const len = Math.min(left.length, right.length);\n const out = Array(len);\n for (let i = 0; i < out.length; i++) {\n out[i] = {x: left[i], y: right[i]};\n }\n return out;\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":190,"value":"angularVelocity = (xy) => {\n const arr = Array(xy.length - 1);\n for (let i = 0; i < arr.length; i++) {\n arr[i] = angleDifference(xy[i], xy[i+1]);\n }\n return arr;\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":826,"value":"integrate = (arr) => {\n const out = Array(arr.length);\n let sum = 0;\n for (let i = 0; i < out.length; i++) {\n sum += arr[i];\n out[i] = sum;\n }\n return out;\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":587,"value":"digitize = (arr) => {\n const out = new Array(arr.length);\n out[0] = arr[0] > 0 ? 1 : 0;\n for (let i = 1; i < out.length; i++) {\n const threshold = out[i-1] == 1 ? -0.1 : 0.1 \n out[i] = (arr[i] > threshold) ? 1 : 0;\n }\n return out;\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":722,"value":"centerXY = (xy) => {\n const xs = center(xy.map(({x, y}) => x));\n const ys = center(xy.map(({x, y}) => y));\n return zipXY(xs, ys);\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":720,"value":"normalizeRadius = (xy) => xy.map(({x, y}) => {\n const r = Math.sqrt(x*x + y*y);\n return {x: x/r, y: y/r};\n});","pinned":true,"hidden":false,"mode":"ojs"}],"files":"$W32","stdlib":"1","titling":"auto"}