# Bezier curves in hardware? (X-Y-mode on oscilloscope)

As I am exploring how to use an oscilloscope as a raster display in a question yesterday, and building the circuit, I am finding that with about the same (even less) components I could build a vector display also, where I just draw from point to point with Z-channel (intensity) either on or off, like a plotter, pen down or pen up. And as I designed a character mode for the raster display, I am thinking of a character mode for the vector display. In that design I have two 8-bit DACs for 256 x 256 positions on the scope. I have 5 bits of the DAC fed by the character cell position (32 x 32 characters), reading the character code from memory (1 byte per character) and then finding the character model in the char ROM.

In raster display mode we all know how this works: each byte of the char ROM data is 8 pixels, that we then shift the pixels out to the Z-channel (assuming right now the classical 8x8 character matrix.) And it's just a matter of how to connect the address lines and run the counters to arrange the char ROM in 8 consecutive bytes for the 8 rows of pixels of each character.

But instead of 8x8 pixels, I could have, each byte represent one stroke in a cell of 8x8 points.

+---+---+---+---+---+---+---+---+
| 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
+---+---+---+---+---+---+---+---+
| Z-ctl | Y-coord . | X-coord.  |
+-------+-----------+-----------+


Where X-coordinate and Y-coordinate are the destination of the stroke and Z-control says if the beam is on 11 or off 00.

And now I have 2 more values of the Z-control parameter. I could use it for 4 intensity values, allowing a "grayscale" effect ("green-scale", haha). But I am thinking: what if I could bend the straight lines?

So, for example, I could say

• 00 - beam off
• 01 - beam-on, X straight, Y delayed
• 10 - beam-on, X delayed, Y straight
• 11 - beam-on, X straight, Y straight

by straight vs. delayed I mean I use a simple RC delay which will delay the voltage change of one of the channels. Here I show a stroke from 0,0 to 1,1 with first Y-delay (red), the X-delay (blue), and X and Y straight (purple).

This would not be too hard to do. And that way I can draw curvy letters, which is so much better than straight, as it could even reduce the number of strokes. Imagine the D would have 4 strokes instead of 5, or the B would have 6 strokes instead of 10 and would look much better.

But -- now comes the question -- the RC function is not really that pretty and I wonder if circular arcs or, best, Bezier curves could be generated in hardware? Specifically the quadratic Bezier curves. Have people built analog function generators to achieve such an effect?

Note: I only care for analog or hardware digital, not computed methods. I know one can throw a micro-controller or an FPGA at anything and call it "hardware".

I'm also aware for the "oscilloscope music" movement which uses the two stereo channels to draw any curves. What I'm thinking of might even be related to that oscilloscope music movement, except that I would generate these wave form segments with some simple digitally controlled analog circuit, without preparing it on a computer.

Perhaps I should think about the RC curve as a Bezier curve and by selection of the time constant and the onset and end point of the stroke one might emulate it. It's mind-boggling. Someone should have thought about that idea, but I can't seem to find anything on Google.

• How are you going to 'compute' an arbitrary curve in analog hardware? You could probably get an equivalent circuit to do one curve, multiple curves? probably not – Voltage Spike Jul 20 '20 at 18:07
• would Intensity be velocity or slew rate controlled for Vector text? – Tony Stewart EE75 Jul 20 '20 at 18:21

I've once made a digital second order interpoler with just adders and shifts.

Bezier curves are second order curves. Lines are first order.

To draw lines, you use an integrator :

Pos0 = Initial value
Pos = Pos + Speed * Time


To draw second order curves, you can use two integrators :

Speed0 = Initial value
Pos0 = Initial value
Speed = Speed + Acceleration * Time
Pos = Pos + Speed * Time


With initial values for Position, Speed and a constant Acceleration (taking a mechanical analogy), you can draw parabolic curves (like throwing an object).

Repeat for X and Y positions.

Consider an architecture where you have a memory device acting as a look-up-table: 256 x 8-bits, so you have 8 bits in & 8 bits out. This could hold an arbitrary pattern. This may be one-time programmable, or could be SRAM based and changed under software control.

You could have your existing co-ordinates feeding into this, so you have an output which can be any f(x,y), or it could be indexed independently.

Taking the output of this into a multiplying DAC, then summing the output into your existing driver, will allow you scaling ( including turning it off ) - allowing you to define a fixed shape ( a curve say ), which could then be drawn at whatever size needed. Positioning this scaled shape in X & Y adds some complication - but could be done.