Phosphor Screen Simulation

[gregkovacs]

Folks,
I'm working on a way to achieve the same "slowly fading" effect of a slow phosphor CRT as seen here:

Noise Video


vimeo.com/2938447920

The example shows low-pass-filtered white noise from an avalanche-breakdown transistor for X- and Y-axes (truly random). If sampled at around 100 samples/second, the signal should be faithfully captured. However, the fading effect, which is very cool, takes place over many seconds, which seems to preclude storing that many points (maybe 10,000 x/y pairs) and fading them exponentially over maybe 10 seconds with a circular buffer approach.

The goal is to sample analog noise with a Teensy 3.6 and display it in a "slow phosphor" way on a Gameduino 3.

I have some ideas to try, but if anyone has any to share, it would be much appreciated.

Thanks,
Greg

[jamesbowman]

It's a really nice effect.

I think that keeping 1000 points in main RAM and drawing them in a loop might work.
At 4 bytes per point, the Teensy 3.6 should easily be able to draw them at 60 Hz, with a fade factor.

I'm planning to code something up today, and will send it out in the Excamera newsletter tomorrow:


tinyletter.com/jamesbowman

[jamesbowman]

All written up: tinyletter.com/jamesbowman/letters/simulating-a-slow-phosphor-crt-on-gameduino-3

[gregkovacs]

James,
As previously noted, you are amazing! Thank you so much!!!!

I can send you one of the noise generator boards if you like.

Thanks,
Greg

[gregkovacs]

James,
I realized I didn't fully understand your code (sorry, I'm mostly a hardware guy when I went in and thought I'd just replace the source of the x, y coordinates for each stored point with something like:
x = analogRead(A3);
y = analogRead(A4);

Of course, that's not how it works...

My goal here is to X-Y plot two analog signals - truly and entirely random, from physics - and connect between the points with a series of slowly decaying traces.

You have made a very realistic trace display!

What I need to do is figure out how to feed your code X, Y values (from two analog inputs) at a rate I can specify (e.g., 10 Hz) and have an independent "fade" rate. For a phosphor, it is a physical property, and the light decays exponentially, creating a characteristic visual effect.

I built the original with vintage slow-phosphor cathode ray tubes, and would like to simulate X-Y display faithfully so I and others can implement cool signal-driven art pieces (stereo music L/R channels, lowpass filtered to prevent aliasing) makes a very cool "fuzzball" that changes with the music. In this case, I was looking at noise from avalanching in transistors, but it could be anything.

A basic X-Y plot demo that give about 70 kHs/s sample rate on a Teensy 3.6 running normal speed is below.

I'm not asking you to write my code for me, but maybe point me to how I could feed it X-Y pairs and, hopefully, independently control the fade rate.

Thanks,
Greg


#include <EEPROM.h>
#include <SPI.h>
#include <GD2.h>

//Gameduino 3 + Teensy 3.6 Test Code
//G. Kovacs, 7/25/18
//Basics:
//X = 480, Y = 282 pixels

void setup()
{
GD.begin(~GD_STORAGE);
analogWriteResolution(8);
analogReadResolution(8);
}

void loop()
{
GD.ClearColorRGB(0x103000);
GD.Clear();
GD.cmd_text(240, 141, 31, OPT_CENTER, "XY Display Demo");
GD.Begin(POINTS);
GD.ColorRGB(0x00FF00); // bright green
for (int i = 0; i < 1000; i++) {
GD.Vertex2ii(analogRead(A3),analogRead(A4));

// GD.Vertex2ii(map(analogRead(A3),0,255,0,479),map(analogRead(A4),0,255,281,0));
}
GD.swap();
}

[gregkovacs]

Update. While the Gameduino 3 has thus far resisted my attempts, I have implemented a true analog fade routine on a 128X128 LED matrix comprised of four 64X64 panels, each with a Teensy 3.6. When I get it running with a Gameduino 3, I will post the code. For now, here are two videos.

The cool thing is that each pixel has its own "analog memory" just like a real phosphor screen, and the main loop simply raster scans and decreases the brightness of each point that has been written to. I get pretty good bandwidth this way, although there are still a few visual glitches at the panel interfaces.

This one is 10Hz noise: vimeo.com/307797922

This one is 400/800 Hz sinewaves for a Lissajous figure: vimeo.com/307797837

Thanks,
Greg

[gregkovacs]

No worries if folks are too busy or not interested, but here's where I'm leaving this. I can make beautiful simulations (fast) on RGB LED matrices or (slow) on Adafruit LCD's. With the Gameduino 3, without causing "processor exceptions" with too many points before a buffer swap, my proven approach yields a black screen unless I plot a fixed color ("intensity").

It's probably something stupid on my part.

The basic idea (which works fine at good frame rates on other displays) is to have the Teensy 3.6 scan the intensity array continuously and, if it finds any pixels with intensity > 0, decrement them. The cool way is to convert to float, multiply by a decay factor such as 0.95, and back to uint8_t or byte. However, *any* operations on the intensity array in the Gameduino 3 version seems to lead to a black screen and I don't get it.

Oh well. Other stuff coming soon - easy, fast oscilloscope with Teensy and Gameduino 3.

Thanks and Happy Holidays!
Greg




#include <EEPROM.h>
#include <SPI.h>
#include <GD2.h>

//Gameduino 3 + Teensy 3.6 Test Code
//G. Kovacs, 7/25/18, 7/27/18, 12/17/18
//Note: discovered on 7/27/18 that 2023 is the MAXIMUM number of points that can be drawn without causing a "Coprocessor Exception" error. Buffer size?
//X = 480, Y = 272 pixels
//12/17/18 Try to port proven fade algorithm .

#define arraysize 128

int xpin = A5, ypin = A4;
byte intensity[arraysize] [arraysize];
int samplePeriod = 30; //Sample period for interrupts in microseconds
int x, y, xcount, ycount;

// Create IntervalTimer object to sample the x and y inputs...
IntervalTimer sampleTimer;

void setup()
//Clear intensity array just in case...
{
for (ycount = 0; ycount<=arraysize; ycount++)
{
for (xcount=0; xcount<=arraysize; xcount++)
{
intensity[xcount][ycount]=0;
}
}

GD.begin(~GD_STORAGE);
analogReadResolution(7); //Adjust so that max binary value is equal to arraysize-1, i.e., 7 bits for 128-element intensity array.
sampleTimer.begin (sample, samplePeriod); //Period of sampling is second parameter, in microseconds. Empirically looks like 15 - 20 us is minimum. This code 30 us.
}

void sample() //Drives the "virtual electron beam" that writes intensity values on interrupt into the intensity array.
{
x=analogRead(xpin);
y=analogRead(ypin);
intensity[x][y] = 255;
}

void loop()
{
// delay(10);
GD.ClearColorRGB(0x1030FF);
GD.Clear();
GD.cmd_text(240, 141, 31, OPT_CENTER, "XY Display Debug");
GD.Begin(POINTS);
for (ycount = 0; ycount<=arraysize; ycount++)
{
for (xcount=0; xcount<=arraysize; xcount++)
{
if (intensity[xcount][ycount]>0)
{
GD.ColorRGB(intensity[xcount][ycount]*0x1000); //This does work, but as soon as any operation is done on the intensity array, it does not!
GD.Vertex2ii(xcount, ycount);
intensity[xcount][ycount]=intensity[xcount][ycount]; // This useless operation (likely ignored by the compiler) works.
// Proven approach is to convert to float, multiply, and convert back.
// intensity[xcount][ycount]=int(intensity[xcount][ycount]*.95); //Does not work with Gameduino 3
// intensity[xcount][ycount]=intensity[xcount][ycount]>>1; // This does not work either.
// It does not work for even tiny array sizes like 32 elements, so it is not buffer overflow, and few points get written anyway.
}
}
// GD.swap();
}
GD.swap();

}