31:T730,There is a jump in response to each tick, and then an exponential decay. With a higher-resolution encoder wheel, this will more closely resemble the original graph, but it still isn't smooth. This is because each tick is an impulse (a one followed by zeros), and as a result we get a bunch of overlapping copies of the filter's impulse response, added together. An RC filter's impulse response is a spike followed by exponential decay. ## Where does the lag come from? You can see that this filter adds lag to the output since the graph is shifted to the right compared to the original. There are two sources of lag: ### Tick lag Each tick summarizes a partial rotation that happened *before* the tick. For example, if there are two ticks per cycle, each tick summarizes a half turn's rotation, and the lag will average to about a quarter turn. This lag *varies with speed,* because the ticks come closer together at higher speeds. Increasing ticks per turn will reduce tick lag as well as improving precision. ### Filter lag A filter's response to a tick comes after it, as determined by the impulse response. A longer impulse response aggregates each tick with more of the other ticks, but it will shift the curve to the right more. ### Adjusting for lag Why didn't binning cause much lag? Because as a filter, it's *acausal*. You can't actually draw a bin until you've counted all the ticks in its time interval, so the graph couldn't be drawn in real time. (Binning still has the tick lag, too, but it's not very obvious.) Measuring the distance between ticks is acausal as well, because you don't know when the next tick will be until you've reached it. For the other filters, if we're not calculating the speed in real time, we could adjust for filter lag by shifting the whole curve to the left. ## A moving average filter32:[] 2f:{"title":"Tachometer signal processing","cells":[{"id":0,"value":"# Tachometer signal processing","pinned":false,"hidden":false,"mode":"md"},{"id":10,"value":"A tachometer measures the rotation speed of something that spins, like a wheel, an axle, or an engine. There are many ways to do this, but often there is a sensor that measures something that changes as the wheel spins. From a digital signal processing point of view, we typically have a periodic waveform whose frequency varies, and we want to measure the frequency.","pinned":false,"hidden":false,"mode":"md"},{"id":21,"value":"Let's start by defining the *ground truth* for a running example. Here is a graph defining the velocity of the wheel. Velocity is in distance over time, and we will measure distance in *rotations* and time based on how many *samples* our programs sees in that time.","pinned":false,"hidden":false,"mode":"md"},{"id":48,"value":"Plot.plot({\n grid: true,\n height: 300,\n y: {label: \"Rotations per thousand samples\", zero: true},\n marks: [\n Plot.lineY(originalVelocity, {x: (d, i) => i, y: d => d * 1000, stroke: \"blue\"})\n ],\n});","pinned":false,"hidden":false,"mode":"ojs"},{"id":35,"value":"viewof exampleName = Inputs.radio(examples.keys(), {label: \"Example to use\", value: \"start and stop\"})","pinned":false,"hidden":false,"mode":"ojs"},{"id":616,"value":"## The Sensor\n\nThere are many ways to sense rotation, and you can read more about them in [Wikipedia](https://en.wikipedia.org/wiki/Rotary_encoder). Let's assume we do it optically. An optical sensor and a black-and-white patterned wheel can be used to create a signal that changes as the wheel turns. You can move the slider to change the number of black-and-white areas on the wheel.","pinned":false,"hidden":false,"mode":"md"},{"id":591,"value":"wheel = PieChart(wheelPattern, {\n name: d => d,\n value: d => 1,\n title: d => \"\",\n innerRadius: 75,\n colors: [\"black\", \"white\"],\n width: 300,\n height: 300\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":132,"value":"viewof pulsesPerTurn = Inputs.range([1, 10], {value: 1, step: 1, label: \"Pulses Per Turn\"})","pinned":false,"hidden":false,"mode":"ojs"},{"id":101,"value":"Suppose the black parts of the wheel are sensed at zeroes and white parts as ones. If something turns the wheel according to the *ground truth* graph, the resulting signal might look like this:","pinned":false,"hidden":false,"mode":"md"},{"id":119,"value":"Plot.plot({\n grid: true,\n height: 300,\n y: {domain: [-1, 2]},\n marks: [\n Plot.lineY(pulses, {x: (d, i) => i})\n ],\n});","pinned":false,"hidden":false,"mode":"ojs"},{"id":165,"value":"We can think of these pulses as progress indicators. Each time the signal changes, we know the wheel has rotated a bit. We don't get any information in between, while the signal is constant.\n\nAnother way to represent progress is using *ticks*. Each time the sensor sees a change from black to white, or white to black, it will send a one. Otherwise it sends zero.","pinned":false,"hidden":false,"mode":"md"},{"id":186,"value":"Plot.plot({\n grid: true,\n height: 300,\n y: {domain: [-1, 2]},\n marks: [\n Plot.lineY(ticks, {x: (d, i) => i})\n ],\n});","pinned":false,"hidden":false,"mode":"ojs"},{"id":646,"value":"There are twice as many ticks as pulses, since there is a tick both when going up and going down.","pinned":false,"hidden":false,"mode":"md"},{"id":485,"value":"ticksPerTurn = pulsesPerTurn * 2;","pinned":false,"hidden":false,"mode":"ojs"},{"id":197,"value":"## Counting Ticks Using Bins\n\nSuppose we divide the timeline into fixed-length time periods and count the ticks that happen in each interval. This will give us a stair-step graph:","pinned":false,"hidden":false,"mode":"md"},{"id":208,"value":"Plot.plot({\n x: {domain: [0, 2500]},\n y: {domain: [0, 20]},\n marks: [\n Plot.lineY(originalVelocity,\n {x: (d, i) => i, y: d => d * 1000, stroke: \"blue\"}),\n Plot.rectY(ticks,\n Plot.binX({y: \"sum\"},\n {x: (d, i) => i,\n y: d => d * 1000/(ticksPerTurn * binSize),\n interval: binSize})),\n ]\n});","pinned":false,"hidden":false,"mode":"ojs"},{"id":255,"value":"viewof binSize = Inputs.range([10, 100], {value: 100, step: 1, label: \"Bin Size\"})","pinned":false,"hidden":false,"mode":"ojs"},{"id":248,"value":"You can try making the graph smoother by changing the encoder wheel to send more ticks, and perhaps lowering the bin size. It doesn't look all that much like the original, though. To try to get a smoother graph, let's try some other approaches.","pinned":false,"hidden":false,"mode":"md"},{"id":858,"value":"## Measuring the time between ticks\n\nThe interval between each two ticks measures the time for a fraction of one cycle. From that we can calculate the frequency, and plot it halfway between the two ticks.\n\nIt works pretty well when ticks are a moderate distance apart. If they're too close, it gets noisy because the distance can't be a fraction of a sample. It's unclear what to do when the wheel stops, so there are no ticks.\n","pinned":false,"hidden":false,"mode":"md"},{"id":871,"value":"Plot.plot({\n grid: true,\n height: 300,\n x: {domain: [0, ticks.length]},\n y: {domain: [0, 20]},\n marks: [\n Plot.lineY(originalVelocity, {x: (d, i) => i, y: d => d * 1000, stroke: \"#ddf\"}),\n Plot.line(frequencies, {x: \"x\", y: (d) => d.frequency*1000/ticksPerTurn, curve: \"cardinal\", stroke: \"green\"}),\n // Plot.dot(frequencies, {x: \"x\", y: (d) => d.frequency*1000/ticksPerTurn, stroke: \"green\"}),\n ],\n });","pinned":false,"hidden":false,"mode":"ojs"},{"id":940,"value":"## A simple low-pass filter\n\nThe first filter I tried simulates the decay of an RC analog circuit. There is a single state variable that represents the voltage of the capacitor, which exponentially decays unless it's being charged.","pinned":false,"hidden":false,"mode":"md"},{"id":319,"value":"function makeRcFilter(decay) {\n var state = 0;\n return (input) => {\n state = state * (1 - decay) + input * decay;\n return state;\n }\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":321,"value":"Here's how it looks:","pinned":false,"hidden":false,"mode":"md"},{"id":327,"value":"Plot.plot({\n grid: true,\n height: 300,\n marks: [\n Plot.lineY(originalVelocity, {x: (d, i) => i, y: d => d * 1000, stroke: \"blue\"}),\n Plot.lineY(\n ticks.map(makeRcFilter(rcDecay)),\n {x: (d, i) => i, y: d => d * 1000/ticksPerTurn}),\n ],\n });\n","pinned":false,"hidden":false,"mode":"ojs"},{"id":340,"value":"viewof rcDecay = Inputs.range([0.001, 0.5], \n {value: 0.01, step: 0.001, label: \"Decay Per Sample\", transform: Math.log})","pinned":false,"hidden":false,"mode":"ojs"},{"id":350,"value":"$31","pinned":false,"hidden":false,"mode":"md"},{"id":404,"value":"Plot.plot({\n grid: true,\n height: 300,\n marks: [\n Plot.lineY(originalVelocity, {x: (d, i) => i, y: d => d * 1000, stroke: \"blue\"}),\n Plot.lineY(\n ticks.map(makeMovingAverageFilter(movingAverageWindow)),\n {x: (d, i) => i, y: d => 1000 * d/ticksPerTurn}),\n ],\n });\n","pinned":false,"hidden":false,"mode":"ojs"},{"id":417,"value":"viewof movingAverageWindow = Inputs.range([1, 100], {value: 100, step: 1, label: \"Window width (in samples)\"})","pinned":false,"hidden":false,"mode":"ojs"},{"id":424,"value":"A moving average results in stair-steps because it counts ticks within a window and we don't have fractional ticks. Another way to think about it is that the impulse response of a moving average is a rectangle, and we're adding up rectangles. Overlapping rectangles result in stair steps.\n\n## Multiple-pass moving average","pinned":false,"hidden":false,"mode":"md"},{"id":444,"value":"Plot.plot({\n grid: true,\n height: 300,\n marks: [\n Plot.lineY(originalVelocity, {x: (d, i) => i, y: d => d * 1000, stroke: \"blue\"}),\n\n Plot.lineY(\n ticks.map(makeMultipassFilter(multiMovingAverageWindow, passes)),\n {x: (d, i) => i, y: d => 1000 * d / ticksPerTurn}),\n ],\n });\n","pinned":false,"hidden":false,"mode":"ojs"},{"id":663,"value":"viewof multiMovingAverageWindow = Inputs.range([1, 100], {value: 100, step: 1, label: \"Window width (in samples)\"})","pinned":false,"hidden":false,"mode":"ojs"},{"id":446,"value":"viewof passes = Inputs.range([1, 10], {value: 5, step: 1, label: \"Passes\"})","pinned":false,"hidden":false,"mode":"ojs"},{"id":502,"value":"If you run a moving average over the data multiple times, the impulse response of the filter converges on a bell curve. (You can see this better by reducing the window width and pulses per rotation so the ticks don't overlap. Each one will be a little bell curve.)\n\nIf the ticks are close enough together that their impulse responses overlap, the graph looks pretty smooth. Additional filter passes add latency, though, by making the impulse response wider.","pinned":false,"hidden":false,"mode":"md"},{"id":692,"value":"## Other impulse responses\n\nBy using [convolution](https://observablehq.com/@skybrian/understanding-convolution) we can pick any impulse response we want, but the code will run slower. Here are some other choices:","pinned":false,"hidden":false,"mode":"md"},{"id":723,"value":"Plot.plot({\n grid: true,\n height: 300,\n width: Math.max(100, impulseResponseWidth * 5),\n y: {zero: true},\n marks: [\n Plot.dot(impulseResponse, {x: (d, i) => i, y: d => d})\n ],\n});","pinned":false,"hidden":false,"mode":"ojs"},{"id":719,"value":"viewof impulseResponseName = Inputs.radio(impulseResponses.keys(), {label: \"Impulse response to use\", value: \"windowed sinc (Blackmun)\"})","pinned":false,"hidden":false,"mode":"ojs"},{"id":728,"value":"viewof impulseResponseWidth = Inputs.range([5, 200], {value: 200, step: 1, label: \"Window width (in samples)\"})","pinned":false,"hidden":false,"mode":"ojs"},{"id":825,"value":"Plot.plot({\n grid: true,\n height: 300,\n marks: [\n Plot.lineY(originalVelocity, {x: (d, i) => i, y: d => d * 1000, stroke: \"blue\"}),\n\n Plot.lineY(\n convolute(ticks, impulseResponse),\n {x: (d, i) => i, y: d => 1000 * d / ticksPerTurn}),\n ],\n });","pinned":false,"hidden":false,"mode":"ojs"},{"id":844,"value":"It seems that using a smooth curves as a low-pass filter gives us roughly similar results. When the ticks are far enough apart, you see the individual impulse responses.","pinned":false,"hidden":false,"mode":"md"},{"id":652,"value":"## Beyond counting ticks\n\nWith this kind of sensor, we are taking rotation, which is continuous and smooth, and turning into ticks, which are discrete events. Then we try to smooth it out again. More smoothing is needed at lower frequencies, but this results in more lag. A question for sensor experts: is it possible to measure slow rotations in a more continuous way?","pinned":false,"hidden":false,"mode":"md"},{"id":40,"value":"## Implementation","pinned":false,"hidden":false,"mode":"md"},{"id":25,"value":"examples = new Map([\n [\"start and stop\", () => {\n let a = Array(2500).fill(0);\n let scale = 0.008;\n for (let i = 100; i < 600; i++) {\n a[i] = scale * (-Math.cos((i - 100) * Math.PI * 0.002) + 1);\n }\n for (let i = 600; i < 1000; i++) {\n a[i] = scale * 2;\n }\n for (let i = 1000; i < 2000; i++) {\n a[i] = scale * (Math.cos((i - 1000) * Math.PI * 0.001) + 1);\n }\n \n return a;\n }], \n [\"constant acceleration\", () => {\n let a = Array(2500);\n let v = 0;\n for (let i = 0; i < a.length; i++) {\n a[i] = v;\n v += 0.000008;\n }\n return a;\n }],\n [\"forward and backward\", () => {\n let a = Array(2500);\n for (let i = 0; i < a.length; i++) {\n a[i] = 0.01 * Math.sin(i * Math.PI * 0.0012);\n }\n return a;\n }],\n])\n","pinned":false,"hidden":false,"mode":"ojs"},{"id":50,"value":"originalVelocity = examples.get(exampleName)()","pinned":false,"hidden":false,"mode":"ojs"},{"id":594,"value":"wheelPattern = {\n let a = Array(pulsesPerTurn * 2);\n for (let i = 0; i < a.length; i++) {\n a[i] = i % 2;\n }\n return a;\n};","pinned":false,"hidden":false,"mode":"ojs"},{"id":106,"value":"pulses = {\n let a = Array(originalVelocity.length);\n var cycles = 0;\n a[0] = 0;\n for (let i = 1; i < a.length; i++) {\n let averageVelocity = (originalVelocity[i-1] + originalVelocity[i]) / 2;\n cycles += averageVelocity;\n a[i] = ((cycles * pulsesPerTurn) % 1) >= 0.5 ? 1 : 0;\n }\n return a;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":174,"value":"ticks = {\n let a = Array(pulses.length);\n var pulseHigh = false;\n for (let i = 0; i < pulses.length; i++) {\n var nextHigh = pulses[i] >= 0.5;\n a[i] = pulseHigh == nextHigh ? 0 : 1;\n pulseHigh = nextHigh;\n }\n return a;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":389,"value":"function makeMovingAverageFilter(windowWidth) {\n var sum = 0;\n var queue = Array(windowWidth).fill(0);\n var next = 0;\n var sum = 0;\n return (input) => {\n sum += input;\n sum -= queue[next];\n queue[next] = input;\n next++;\n if (next >= queue.length) {\n next = 0;\n }\n return sum / windowWidth;\n }\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":440,"value":"function makeMultipassFilter(windowWidth, passes) {\n let filters = Array(passes);\n for (let i = 0; i < passes; i++) {\n filters[i] = makeMovingAverageFilter(windowWidth);\n }\n return (input) => {\n for (let i = 0; i < filters.length; i++) {\n input = filters[i](input);\n }\n return input;\n }\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":708,"value":"impulseResponses = new Map([\n [\"Blackmun window\", (width) => makeImpulseResponseArray(width, blackmun((x) => 1, width))],\n [\"windowed sinc (Blackmun)\", (width) => makeImpulseResponseArray(width, blackmun(sinc, width))],\n [\"windowed sinc (Hamming)\", (width) => makeImpulseResponseArray(width, hamming(sinc, width))],\n])","pinned":false,"hidden":false,"mode":"ojs"},{"id":755,"value":"function makeImpulseResponseArray(width, f) {\n let a = Array(width + 1);\n for (let i = 0; i < a.length; i++) {\n a[i] = f(i);\n }\n return a;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":771,"value":"sinc = (x) => {\n if (x === 0) {\n return 1;\n }\n return Math.sin(Math.PI * x) / (Math.PI * x);\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":752,"value":"blackmun = (f, width) => (i) =>\n f((i - width/2)/width) * (0.42 - 0.5 * Math.cos(2 * Math.PI * i / width) + 0.08 * Math.cos(4 * Math.PI * i / width))","pinned":false,"hidden":false,"mode":"ojs"},{"id":744,"value":"hamming = (f, width) => (i) =>\n f((i - width/2)/width) * (0.54 - 0.46 * Math.cos(2 * Math.PI * i / width))","pinned":false,"hidden":false,"mode":"ojs"},{"id":725,"value":"impulseResponse = normalizeArea(impulseResponses.get(impulseResponseName)(impulseResponseWidth))","pinned":false,"hidden":false,"mode":"ojs"},{"id":828,"value":"normalizeArea = (input) => {\n var sum = 0;\n for (let i = 0; i < input.length; i++) {\n sum += input[i];\n }\n let a = Array(input.length);\n for (let i = 0; i < a.length; i++) {\n a[i] = input[i] / sum;\n }\n return a;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":710,"value":"function convolute(a,b) {\n let result = Array(a.length + b.length).fill(0);\n a.forEach((sample, i) => {\n b.forEach((weight, j) => {\n result[i + j] += sample * weight;\n });\n });\n return result;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":872,"value":"crossings = {\n let a = Array();\n var prevTick;\n for (let i = 0; i < ticks.length; i++) {\n if (ticks[i] != 0) {\n a.push(i);\n }\n }\n return a;\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":876,"value":"frequencies = {\n let a = Array();\n // a.push({frequency: 0, x: 0});\n for (let i = 1; i < crossings.length; i++) {\n let period = crossings[i] - crossings[i-1];\n let x = (crossings[i] + crossings[i-1]) / 2;\n a.push({frequency: 1/period, x: x});\n }\n // a.push({frequency: 0, x: ticks.length - 1});\n return a;\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":588,"value":"import {PieChart} from \"@d3/pie-chart\"","pinned":false,"hidden":false,"mode":"ojs"}],"files":"$W32","stdlib":"1","titling":"auto"}