Published June 17, 2023 © CC BY-NC

Star Wars Inspired DIY Volumetric Display

The goal of my project was to create a kind of DIY volumetric display that can be built at home with available components for makers.

AdvancedFull instructions providedOver 1 day2,740

Star Wars Inspired DIY Volumetric Display

Things used in this project

Hardware components

Arduino Mega 2560

Custom PCB

projector

Software apps and online services

Arduino IDE

Hand tools and fabrication machines

3D Printer (generic)

Story

Introduction

A volumetric display is a graphical display device that creates a visual representation of an object in three physical dimensions. It renders a digital representation of a real object in physical space, the resulting image displays similar characteristics to a real world object, allowing an observer to view it from any direction. The three-dimensional images created by volumetric 3D displays are visible to the naked eye. It's just one type of 3D display, and it has always fascinated me more than other common types of 3D displays, such as stereoscopic displays.

video (part 1) shows the device and explains how it works, followed by the projector modification

Although often seen in science fiction, volumetric displays are not yet commonplace. There are professional systems on the market, but they are very expensive. The goal of my project was to create a kind of DIY volumetric display that can be built at home with available components for makers. Of course there are significant limitations of my DIY version compared to the professional volumetric systems available on the market. But the result is remarkable despite the limited possibilities.

Several types of volumetric displays can be observed:

a. self-luminous (e.g. a LED matrix or rotating LED strips)
b. projection-based (projection of points onto a 2D projection plane that periodically sweeps to form a physical volume)
c. cross section based (e.g. multiplanar stacked translucent 2D displays)
d. Holographic (wave optics based systems that reproduce the properties of light waves - amplitude, wavelength, and phase)

My display project belongs to type "b.", it uses a projector and a sweeping volume. The main components for my DIY display are :

1) A fast projector capable of displaying many hundreds of frames per second (more is better)
2) A sweeping projection volume that can be precisely controlled and is fast enough to provide the necessary persistence of vision effect.
3) Electronics for synchronization and control (based on Arduino)
4) Software tools for calibration, content creation and visualization (Windows based software)

1 / 2 • main components : fast projector, swept volume, electronics, source

The basic principle of operation is that the projector shoots a series of images onto the moving projection surface, resulting in a 3D object composed of many layers. For correct operation, the movement of the volume must be synchronized with the projector.

1) A fast projector

To achieve the necessary persistence of vision effect, we need a projector capable of producing several hundred frames per second. There are professional projectors for scientific purposes that can go up to 1000 frames per second and beyond, but they are very expensive. There are also some projects that use the TI "light Crafter" evaluation kit, but I have not been able to get my hands on one.

So can a cheap projector be "hacked"(modified) for this purpose? Yes - sort of. Here is what I did. First, the only type of projector that can achieve these high frames rates is DLP. LCDs are too slow and LCOS too expensive. DLP projectors can easily output 1000Hz frames because they modulate light intensity (grayscale) by switching on and off at several kHz. But the problem is how to control the DMD chip for our purposes. All the magic is in the ASIC and hidden. So we need to find another way. A standard DLP projector used for home theater or office purposes is a projector that uses a DLP chipset to create the image. The chipset is the micromirror device ("DMD") and an ASIC(s) that controls it. The DMD is a chip that consists millions of tiny mirrors which represents the pixels of the image.

Home DLP projectors use only one DLP chip and process RGB light sequentially using a rotating color wheel. A single image is actually a sequence of subframes of red, green and blue image components. Due to the persistence of vision of our eyes, our brain sees a complete color image. Typically 3 or 4 segment color wheels are used. For better color reproduction, 6-segment RGBRGB color wheels are used as well. Some color wheels contain a yellow, cyan, or magenta segment in addition to the RGB segments. They are not suitable for our purpose. For this project, we need a simple wheel with RGB configuration only.

1 / 2 • DLP Projector with RGB color wheel

1.1 Modification of a standard DLP projector

The simple idea is to use the RGB color subframes as individual monochrome frames. If the color wheel is moved out of the projector's optical path (it can't be removed completey since the projector would no longer work), we get a bunch of additional black and white images that used to be the R, G, B planes. Basically, we sacrifice color and gain frame rate. Which projector to look for ? Here are my search criteria:

must be a DLP type
should have a simple color wheel configuration such as RGBRGB or RGBW (no RGBCMY or something like this)
capable of accepting vertical input rates >60Hz, ideally 120Hz or more
affordable

After some research, my choice was the Benq W1070. Introduced in 2013, it was (and still is) an excellent 1080p projector for home cinema and office use. It accepts 120Hz input for DLP3D and according to available documentation it has a RGBRGB color wheel. Meanwhile it has been discontinued by BenQ and can be purchased used in the 100-200EUR range. Please have a look at my video for detailed step-by-step instructions on how I did this modification.

Relocation of the color wheel : The best location I found is where the speaker was previously mounted. Of course this is only one possiblity.

Sensor-cable: I simply attached additional wires in parallel to the sensor, so that we can later analyze the sensor signal.

1 / 4 • projector fully disassembled

DISCLAIMER: Projectors contain high voltage components. Modification and/or disassembly may result in fire or electric shock! If you are not sure what you are doing, do not attempt to modify or disassemble the projector !

1.2 Frame sequence analysis

In order to reduce the "rainbow effect" of DLP projectors, most color wheels cycle through the RGB planes a number of times per frame. So projectors show repeating RGB planes multiple times per frame quickly to reduce this effect. However, these repeated RGB planes are not suitable for our application. The same content would end up multiple times on different Y-positions. The goal is to find a projection mode with a high input frame rate and as few R, G, B subframe repetitions as possible. A good solution for me was to use the "120Hz frame sequential mode" for DLP3D.

Some numbers:

This 120Hz mode provides consecutive 120Hz R, G, B images : 120Hz*3 = 360Hz
To avoid flickering, the total "Volume Refresh Rate" should not be less than 30Hz (but also does not need to be much higher).
With 360fps and 30Hz volume refresh, we will get 12 vertical planes for our volume : 360fps/30Hz=12
Not impressive enough? How about this: At Full HD input, we get 24.8 million voxels : 1920x1080x12 = 24.8M (!)

Back to our 120Hz input mode. It is intended for DLP3D and will sequentially generate a high refresh rate. Don't be confused by the term DLP "3D" : We only use the highest possible frame rate of the projector, which happens to be this mode! Later on, the Arduino will control the projector via RS232 and will set this mode. The frame sequence for this mode is shown below.

120Hz frame sequential mode

A remaining problem is that the projector stream contains unnecessary elements, such as a "sync flash" to trigger the 3D viewing system. We need to block these (and other) elements from the projector stream. How to do that ?

1.3 Adding a shutter

This can be done using a LCD shutter (sometimes also called "light valves"). Basically a shutter is "one huge LCD pixel", which will block or unblock the light passing though it. It's a liquid crystal display without a backlight and is used to control the amount of light passing through an optical system. If the shutter is fast enough, we can select each subframe from the projector stream individually.

I tried a couple of commercially available light valves but due to switching speed, the best option was to re-use an old pair of old TV "active shutter glasses" which were used in the passed 3D-TV era. They usually can flip in less than 1ms and can easily achieve 144Hz or more. In order to reproduce the shutter control signal later, the signal was first analyzed in the working 3D glasses (Note : This signal of course depends very much on the model). In my case, I measured the follwing signal on the control wires : The control voltage oscillates around +9V..0..-9V. They become opaque at +9V and -9V and will be transparent when shorted (0V).

1 / 7 • measuring the required control signal

The shutter element was carefully removed and 2 wires were attached. They will later be controlled by the electronics (see section below). I mounted the projector on a base plate and used aluminum profiles to create a solid frame around it.

To be able to project upwards, I used an angled mirror and placed the shutter on top. This element is what I call the projector front unit. All front unit parts are 3D printed and a link to the STL repository is included below.

What we have so far: The combination of the above elements is a cheap projector modified to produce black and white frames at 360fps that can be addressed individually.

2) The swept volume

For the swept volume, many different projection screens can be observed. Mostly rotating screens can be seen and have been implemented in many forms e.g. as a spinning disk, a helix winding around the vertical axis, etc...I also used rotating volumes for first experiements, as it's easy to start with. However I realized that the rotation surface provides a number of disadantages.

video (part 2) touches on the projection volume, the electronics, the software, and the Star Wars design

There are distortions coming from the projection onto a tilted surface and fast rotations needs to be precisely sync'ed with the projector frames. Also, I wanted something more "linear" and a rear-projection method. Ideally a projection plane that moves up and down. So how to precisely control a 30Hz plane movement?

2.1 Destroying speakers

My inspiration for the linear swept volume technology came from watching my speakers while listening to music... voice coils ! Voice coils are able to produce fast linear movements and are relatively cheap. So I ended up in modifying old (bass) speakers into cheap linear coil actuators. The speakers are cannibalized - so that only the permanent magnet, the voice coil and the "spider" (flexible suspension that forces the voice coil to move axially) remain. Finally the outer basket and the diaphragm are removed. Those speaker don't "speak" anymore, they only vibrate. (Hi-Fi enthusiasts, please don't hate me, these were cheap old speakers... :-)

speakers turned into DIY linear voice coil actuators

The voice coils are driven by a cheap 2-channel audio amplifier module, which does not have to be a "class D" type or anything fancy. In the end, a simple sine wave around 30Hz is all we need. The analog sine wave input for the amp is generated by the Arduino in-sync with our projector. To realize the rear projection surface, a rear-projection foil on a thin transparent plastic sheet is used. This surface needs to swing up and down vertically driven by the coils. So we need some flexible levers to hold the surface and at the same time transmit and amplify the movement of the coils.

2.2 Flexible structures

I decided to try "compliant mechanisms" for the first time. Compliant mechanisms are flexible structures that transfer an input displacement to another point though elastic body deformation. The beauty of these structures is that they are easy to 3D print. They are also lighter and do not need springs etc. All joints in my final mechanism are composed by flexures in a parallel structure. Due to the integration of this compliant and parallel mechanism, the motion of the projection surface is guided by mechanical constraints from the parallel structure to move only vertically. In early versions, I used standard 3D printing materials like PLA or PETG for my experiments. But I soon realized that these materials are not ideal. Such standard printing materials are too stiff, and my structure has always been broken after a certain period of use. The reason is because PLA or PETG are not elastic enough, they have a high flexural modulus. So is there a material which we can 3d print which can withstand the necessary elastic deformations for a long time ? Yes : Polypropylene (PP).

Polypropylene is an ideal material for this purpose because it can deform without breaking and it's very flexible. It is tough, light and has a high fatigue resistance. It fully retains its shape after being bent. This makes it suitable for living hinges which are usually not achievable with more familiar 3D printing materials like PLA etc. Many living-hinges are made from PP (e.g. the famous TicTac box cover). However, it is more difficult to print, which is why it is not (yet?) widely used in 3D printing: PP often warps and has poor bed adhesion. After reading about it, I really expected a lot of problems, but to my surprise, printing worked really well with a few tips I found:

to increase bed adhesion: PP loves to stick to itself, and most packing tapes are made of polypropylene. So I used a clear packing tape made of PP. (it almost stuck too well... it was hard to remove!)
to avoid warping issues : I added a large brim and fence to the slicer, which provided good stability during the printing process.
Finally I tuned the default profile slightly towards very slow printing speeds (50mm/s max). The drawback is obviously that the print takes quite long, but thankfully my structures are not too big. Print time was around 3h which was ok for me.

All of the above lead to successful prints - even without an enclosure. The results are excellent. The structures amplify the vibrations perfectly without breaking. And now I can stretch the projection volume up to 15-20mm without risk of damage.

1 / 3 • projection surface driven by voice coils

3) Electronics

The Arduino + circuit is necessary to "glue" everything together. Here are all the main tasks for the Arduino electronics:

3.1 synchronize with the projector (color wheel signal measured by the Ardunio)
3.2 drive the voice coils to move the projection surface in sync with the projector (low-pass-filtered PWM with offset compensation)
3.2 control the shutter to select only relevant parts from the projector output stream (H-bridge)

Secondary functions:

Serial remote control for the projector (RS232)
Front panel controls, such as buttons, a small display, and some LEDs
Provide a serial control and status interface to a PC

(secondary functions are not explained in detail here)

3.1 analyze the projector timing

To get in sync with the projector, we need to "hack" into the color wheel sync signal. This is usually a simple IR sensor that measures the speed of rotation of the disc. The sensor detects when it receives the echo from the reflective part of the wheel and can sense the starting point of each rotation. I added a parallel output (2 wires) to the IR sensor and fed it to an opamp circuit. It's important that we don't interfere with the original signal and that we can and create a proper 5V pulse signal that an Arduino can safely detect on one of the external interrupt pins. This required some signal conditioning. The IR-sensor provides tiny analog pulses which needs to be amplified and run through a schmitt-trigger stage before being fed onto the Arduino input. The circuit I designed consists of a decoupling-stage, non-inverting amplifyer (gain factor around 6) to bring the signal between the "rails" (approx. 3V), and finally the schmitt trigger with a hysterisis of VL=2V, VH=3V. With this circuit we can now reliably generate an external interrupt on the Arduino when a new color wheel rotation starts.

Note: The circuit shown here does not contain the bug that was in the first version (as explained in my video).

Input circuit for the wheel sensor trigger

3.2 drive the voice coils

I use a simple wavetable player that starts on every 2nd color wheel pulse. The wave output (a PWM port on the Arduino) has an adjustable frequency (typ. 30Hz) and therefore results in a waveform that is perfectly synchronized with the projector. The waveform is a simple sine wave (I've experimented with other waveforms, but the result is always a sine motion of the physical projection surface... simply because of the inert behavior of the surface due to its mass and friction).

The PWM output is low-pass filtered and passed through a simple op-amp stage to adjust the level and remove the positive DC offset to make it oscillate around GND level. This allows the connected amplifier and coils to reach their maximum potential and the surface to perform smooth movements.

voice coil signal output to amplifier

3.2 control the shutter

The LCD shutter works like a capacitor. When charged, it becomes opaque - when shorted, it becomes transparent. For simple low frequency applications, applying a digital voltage would be enough - but we need to get the maximum performance (highest switching speed). LCD elements typically perform best when the applied polarity is constantly changing. The signal alternates from high to low in opposite states on the pins. To reproduce the shutter control signal in the shutter glasses, the signal was first analyzed in the working 3D glasses. Of course, this signal depends very much on the model and will be different. I measured the following signal on the control wires:

L293 H-bridge for shutter control

The control voltage oscillates around +9V..0..-9V. They become opaque at +9V and -9V and will be transparent when shorted (0V). To reproduce this waveform, we need an H-bridge (even the 3D glasses ICs have H-bridges built in). I use the well-known L293, which is very common for motor control, but it does exactly the same job without much effort. All it needs is 2 input pins from the Arduino (1A and 2A), a 9V supply and we are good to go. The shutter is connected to 1Y and 2Y respectively. This is the function table for the L293 connected to the shutter:

1A 1Y 2A 2Y Shutter State
H H H H both sides charged (forbidden)
H H L L Charge + side -> blocking (shutter opaque)
L L H H Charge - side -> blocking (shutter opaque)
L L L L both sides grounded -> open (shutter transparent)

The Arduino is able to switch the state precisely during the output of the wave, so we can choose which part of the projected planes we want to get on our surface.

After extensive testing on a breadboard, all functions were finally consolidated onto a single PCB. The PCB was designed in KiCAD and consists of all the functions described above. The complete schematic is included below.

1 / 5 • custom PCB for this project

4) Software

4.1 Calibration tool

Each of the 12 frames appears at a unique vertical position of the moving projection plane. Since the plane moves up and down, the frame position has no direct relation (frame number -> Y-position), but they appear somehow mixed up. This depends on the phase of the sine wave. In order to display the correct 3D objects, we first have to find out the correct mapping (subframe sequence -> Y-position). To do this, I created a tool that displays a test pattern with 12 numbered stripes (R, G, B planes), each of which can be rearranged. By arranging all the strips in an ascending Y-order, we can find the assignment. This only needs to be done once. The final configuration is stored in a layer configuration file (VolDisLayerConf.vdl).

1 / 2 • tool for assigning the layers to their vertical positions

4.2 Slicer

To create 3D objects for this machine, we need to slice 3D models into 12 layers and assign them to frames according to their Y-position. I created a simple slicer tool for Windows that reads common 3D file formats like STL, OBJ, etc. and allows to adjust the object position and orientation. It creates 12 slices of this object with their corresponding monochrome images. The tool reads the layer-config file we found earlier and is able to assign the 12 layers correctly (Y-position -> frame-number). The monochrome images are recolored in pure R, G, B to match the correct frame and then saved as final bitmaps. I use 2 bitmaps for an object in the 120Hz "side-by-side format", which squeezes 2 bitmaps into one, allowing the projector input to be driven with only 60Hz instead of 120Hz. Each bitmap contains 2 sides with 3 frames each of R, G and B - a total of 12 frames.

the slicer tool I created for this project

4.3 Player

Finally, the player application reads these 2 bitmaps and displays them in strinct vsync with a 60Hz output generated by the GPU. The player is designed to run on the built-in single board computer Lattepanda, as I wanted to have a standalone unit. Alternatively, a connected PC can be used - the external video input is located on the side "droid" panel and the input can be changed from the Arduino using the menu. The player application works with a number of subdirectories, which can contain either a static object (2 bitmaps with 12 layers) or animations - a series of bitmap pairs. In any case, the entire content of a subdirectory is repeated endlessly until the next source directory is selected. All 3 tools (Calibration, Slicer, and Player) are standalone Windows applications (.EXE).

the player application displays bitmaps created by the slicer to visualize 3d objects

NOTE : The tools created for this project are not included here. But I am happy to make them available if you are interested. Simply drop me a note.Please also be aware that they are not fully tested and probably not perfect. Use them at your own risk. However, they worked well for my project.

4.4 Arduino Script

The Arduino script (included below) is divided into several modules for better readability. The module "Volumetric14.ino" contains the 3 main functions :

Analyze the projector timing : After one full revolution, the color wheel sensor triggers an interrupt on pin D18 (BRGBRG sequence typ each 8.3ms or 120Hz). The assigned interrupt function measures the frequency and restarts the waveform output after 2 interrupts.
Drive the voice coils : When started, the waveform output is controlled by the TIMER4 interrupt of the MEGA. The interrupt frequency is typically set to 30Hz (256 table entries -> 130us for 30Hz). On each TIMER4 interrupt, the waveform table is incremented (see the sinus.h include file) and the PWM output pin D3 is updated accordingly. The PWM is controlled by TIMER3 on the MEGA.
Control the shutter : In the same TIMER4 interrupt function, the L294 IC is controlled by 2 pins of the Arduino 1A and 2A. The corresponding IC outputs to the shutter are 1Y and 2Y.

Secondary functions of the Arduino script are: Handling serial communication to PC and projector, controlling OLED display, rotary knob, LEDs and buttons. In order not to make this article too long, they are not explained in detail here. See the module source code and comments for more details.

Why the Mega again...?

First, I needed a lot of memory, pins and available timers. Then, to add a serial interface from the Arduino to the projector for this purpose, the Arduino Mega provides a number of hardware UARTs. Almost no other Arduino has multiple hardware UARTs. This is necessary because the command protocol requires simultaneous sending and receiving. So no software UART can be used. To connect the TTL (Transistor-Transistor Logic) level signals from the Arduino UART to the RS232 interface, I use a cheap converter module.

5) Star Wars inspired housing

From the first time I saw a working 3D image, there was this association with a Star Wars holoprojector. Those pale, translucent, volumetric appearances of 3D objects floating in mid-air are what we have all seen in the movies. And being a Star Wars fan, I just had to give it the look and feel of a console from a galaxy far, far away... For the front and side covers, I decided to use layered panels with the typical elements like square tiled red and white buttons, lots of LEDs, white pin stripes and the inevitable greeblies used in most other designs. The panels are 3d printed - a link to the STL files is included below.

The USB connector for debugging the Arduino has to be a droid interface, of course - and finally, after a bit of weathering, it almost looks like it has been used on a hidden rebel base for years...

1 / 3 • the 3d printed control panels

The user interface is divided into several parts: the Arduino controls include buttons to turn the projector on and off, to enable wave output to the coils (to move the projection plane), and a sync button to turn off sync to the projector. This sync button can produce interesting effects: The layers start moving slowly up and down when the 30Hz output frequency is no longer synchronized to the projector. This can lead to cool animations for symmetrical objects like a cone, etc. See the end of my second video for examples. The "Volume Knob" allows you to control the vertical size of the volume (sine wave amplitude for the voice coils). To have a small menu on the machine, I implemented a rotary encoder knob and an OLED display. This allows to change parameters like phase, frequency, shutter on/off positions etc. and can show some status information. Finally, the Lattepanda display shows the player frontend, where the objects from the subdirectories are displayed and can be selected. Some additional options like vsync, auto-play etc. are also available, but the main purpose is to select the desired objects. The player menu itself is also based on the minimalist Star Wars screen design.

Conclusion

This project was a long journey with many dead ends. It took me more than a year to complete this machine, and I encountered completely new areas of technology that I had never touched before (e.g. compliant structures). There are certainly many limitations in this design (such as only 12 layers, only monochrome, etc.). But in the end it is a DIY project and not a professional product.

For the future, there may be a lot of room for improvement in the design - maybe second-hand gaming projectors that accept 240Hz input will be cheaper soon?

And before you ask: No, I never managed to create the iconic Princess Leia hologram scene, but that was more due to a lack of 3D source material.

Anyway, I am really happy with the result and hope that some of you will find it interesting. Thanks for reading. I look forward to your comments.

Mac

Schematics

Code

/*
Volumetric Display Project
==========================

History
(older experimental versions not listed)
V1.0  10.10.22 first functional verison based on UNO, wavetable implemented, projector sync input connected
V1.1  28.12.22 Lightvalve circuit based on L293, Serial Control for W1070 projector added
V1.2  26.03.23 Change to MEGA after Memory was exhausted on UNO , OLED display added
V1.3  21.04.23 Rotary Encoder with Menu and Buttons for font panel added
V1.4  10.06.23 Final version

Description :
  Arduino MEGA script for my DIY Volumetric display project 
  Tasks :
  - analyze the projector timing (measure the color wheel sync signal)
  - drive the voice coils to move the projection surface 
  - flip the light valve in sync with the timing
  - provide a control interface to a PC (-> in module SerialCommand.ino)
  - remote control projector via 2nd serial interface (-> in module ProjectorRemote.ino)
  - handle front panel elements : OLED display, rotary knob, LEDs and buttons  (-> in module FronPanelControls.ino)

Connections :
 - Projector-Sync Input on Pin D18 <--- Color-Wheel-Sensor signal (from Electronics)
 
 - Lowpass Output from PWM-OUT Pin D3: 
  fc=1/(2*PI*R*C)  R=10k  C=10nF -> Fc=1.5kHz
  PWM --R--+--> Out to Audio Amp for Coil driver  
             C
           GND

 - UART2 conncections to MAX232 circuit for serial W1070 projector control :
  TXD-> 16 TX1
  RXD-> 17 RX2

 - Buttons :
  ... D4..D13 

Info on PWMs Timers:                
 0 (controls pin 13, 4);
 1 (controls pin 12, 11);
 2 (controls pin 10, 9);
 3 (controls pin 5, 3, 2);
 4 (controls pin 8, 7, 6);

Maker Mac 
June 2023

*/
 
const String Version = "1.4";     // Version of this module

#include "sinus.h"            // Sine wave-table 256 values

#include <Wire.h>             // I2C Communication library
#include <Adafruit_SSD1306.h> // OLED display based on 1306
#include <Adafruit_GFX.h>     // graphics functions
#include "Adafruit_seesaw.h"  // Adafruit Rotary Encoder 
#include <seesaw_neopixel.h>  // Neopixel on encoder 

#define OLED_ADDR     0x3C    // I2C address of OLED module
#define SCREEN_WIDTH   128    // OLED display width,  in pixels
#define SCREEN_HEIGHT   64    // OLED display height, in pixels
#define SEESAW_ADDR   0x36    // I2C address of encoder module
#define SS_SWITCH       24    // Switch of Encoder
#define SS_NEOPIX        6    // Neopixel of Encoder

// rebel logo bitmap
#define LOGO_WIDTH    128     // logo dimensions
#define LOGO_HEIGHT   64
#include "rebel_logo.h"

// Pin Assigment 
#define PWM_OUT         3           // PWM output for wave-gen out (D3 PWM pin controlled by Timer3) 
#define Proj_PulsePin  18           // input for Projector sync pulse 
#define L293A1         14           // L293 1A for Lightvalve control
#define L293A2         15           // L293 2A for Lightvalve control
#define PanelLED  2                 // all Buttons (input) and LEDs on front panel
#define Button0   4   
#define LEDbtn0   5
#define Button1   6
#define LEDbtn1   7
#define Button2   8
#define LEDbtn2   9
#define Button3   10
#define LEDbtn3   11
#define Button4   12
#define LEDbtn4   13
#define LEDon     255               // define max brighthness for LEDs (needs to be 255 for PWMs sharing Timer4!)

// variables

// set default phase here :
volatile unsigned int wavetable_start=50; // startpoint for wavetable read after sync pulse (determines the phase shift)
volatile unsigned int wavetable_end=49;   // end of wavetable read (=  wavetable_start - 1)

unsigned int wavetable_entries=256;  // number of values in wavetable 
volatile unsigned int wavesample=0;  // index of current entry in wavetable for output
volatile unsigned long PeriodBetweenPulsesProj = 1000000; // Time in us between Projector IR sync pulses
volatile unsigned long LastMeasuredProj;                  // last measurement
volatile boolean update_PulseProj = false;                // shows if a pulse signal was measured recently
float fps_proj;                                           // current projector wheel input fps
volatile unsigned int divider=4;        // divider after N color wheel pulses to trigger new frame 
volatile unsigned int divcount=1;        // counter for pulses 
volatile boolean proj_sync_mode=true;   // true if operation is synced to projector pulses, if false continous operation 
volatile unsigned int valves = 0;      // counter until next valve change
volatile boolean valve_alt = 1;        // for control of alternating block voltages
volatile unsigned int valves_disable = 31; // number of wavetable entries when valves block (position = Ts * valves_disable)
volatile unsigned int valves_enable = 58; // number of wavetable entries when valves open

unsigned long freq = 30;      // desired output freq for coils -> here, normally 30 Hz 
unsigned long fs ;            // freq*wavetable_entries -> output freq * 256 steps of wavetable give sample freq fs
unsigned long Ts ;            // Ts = 1000000/fs;  ->  sample-time Ts=1/fs , value to be set to Timer4 (e.g. 130us for 30Hz)  

boolean output_enabled = false;   // true if wave output is on or off
boolean logfps = false;           // true if value logging is enabled
boolean projector_on = false;     // true if projector has been powered on 
boolean projector_off = false;    // true if projector has been completely powered off (on/off inbetween states are possible!) 
boolean projector_sbs = false;    // true if projector set to sbs mode 
volatile byte output;             // output for PWM value 0-255
unsigned int proj_input = 1;      // selected input of projector (1=VGA ; 2=HDMI1 ; maybe more later ?)

// Host Serial command interface
boolean cmdreceived = false;    // true if new command received
String inputString = "";        // contains the received commandline
String projcommand = "";         // command send string for projector
String projresponse = "";        // answer from projector after command

// User Interface 
const unsigned int menusize=6;   // number of defined menu items including 0 (0..size-1)
const String menuitem[] = { "0.Status", "1.Freq", "2.Phase", "3.LV open", "4.LV close", "5.Set SBS", "6.Input" };  // menu items
signed int menu_position=0;      // current selected menu-item
unsigned int menu_timeout;       // timeout to clear menu when no interaction
signed int encoder_position;  // holds current encoder position
const int MENUTIME=30;           // timeout 3 sec 
unsigned int errorLED_timeout=0;  // timeout to clear Error LED
const int ERRORTIME=100;           // timeout 10 sec

// objects connected to I2C
Adafruit_SSD1306 oled(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
Adafruit_seesaw ss;
seesaw_NeoPixel sspixel = seesaw_NeoPixel(1, SS_NEOPIX, NEO_GRB + NEO_KHZ800);


/* --------------------------------------------------------------------------------------
 Setup after Reset
-------------------------------------------------------------------------------------- */
void setup()
{ 
  int t ; // i,j ; 
  boolean initOK=true;
  
  // init IOs

  // Buttons + LEDs 
  pinMode(PanelLED, OUTPUT);
  analogWrite(PanelLED, 0);    
  pinMode(Button0 , INPUT_PULLUP);
  pinMode(LEDbtn0 , OUTPUT);
  analogWrite(LEDbtn0, 0);              
  pinMode(Button1 , INPUT_PULLUP);
  pinMode(LEDbtn1 , OUTPUT);
  analogWrite(LEDbtn1, 0);              
  pinMode(Button2 , INPUT_PULLUP);
  pinMode(LEDbtn2 , OUTPUT);
  analogWrite(LEDbtn2, 0);
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, LOW); 

  // Wave-Output PWM pin 
  pinMode(PWM_OUT, OUTPUT);                   
 
  // Sync-Input from Projector
  pinMode(Proj_PulsePin, INPUT);                              

  // LightValve driver pins connected to L293 chip
  pinMode(L293A1, OUTPUT);
  digitalWrite(L293A1, 0);
  pinMode(L293A2, OUTPUT);
  digitalWrite(L293A2, 0);

   // Open Host-IF serial0 (built-in interface) for UART via USB to PC for control interface
  Serial.begin(9600);
  t = 50; //wait for serial port to open, max 5 seconds
  while (!Serial) {
      delay(100);
      if ( (t--) == 0 ) {
        initOK=false;
        break;
      }
  }
  // Output Initial message 
  Serial.print(F("\nVolumetric Display\n")); 
  Serial.println(F("==================")); 
  Serial.print(F("Version ="));
  Serial.println(Version);
  Serial.println();

  // initialize OLED display with OLED_ADDR address (normally 0x3C) 
  Serial.print(F("Searching for OLED Display..."));
  if (!oled.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR)) {
    Serial.println(F("ERROR : OLED module allocation failed !!!"));
    initOK=false;
  }
  Serial.println(F("OLED module found."));

  // initialize Rotary Encoder module with SEESAW_ADDR
  Serial.print(F("Searching for Encoder..."));
  if (! ss.begin(SEESAW_ADDR) || ! sspixel.begin(SEESAW_ADDR)) {
    Serial.println(F("ERROR : Couldn't find Encoder on default address !!!"));
    initOK=false;
  }
  Serial.println(F("found Encoder."));
  // check Encoder firmware
  uint32_t version = ((ss.getVersion() >> 16) & 0xFFFF);
  if (version  != 4991){
    Serial.print("Warning : Wrong firmware for Encoder loaded? ");
    Serial.println(version);
  }
  // for the Neopixel on the encoder... 
  sspixel.setBrightness(40);  // ...set brightness 0..255
  sspixel.show();
  // get starting position
  encoder_position = ss.getEncoderPosition();

  delay(250);         // wait for initializing

  // Show Start Message on OLED
  show_main_page();
  oled.setTextSize(1);          
  oled.setCursor(0, 52);        
  oled.print("     Version=");
  oled.println(Version);
  oled.display();      

   // tesing all LEDs
     for (int j=0; j<255; j++) {   
      delay(5);
      analogWrite(LEDbtn0, j);
      analogWrite(LEDbtn1, j);
      analogWrite(LEDbtn2, j);
      analogWrite(PanelLED, j);    
    }                        
     for (int j=255; j>0; j--) {   
      delay(5);
      analogWrite(LEDbtn0, j);
      analogWrite(LEDbtn1, j);
      analogWrite(LEDbtn2, j);
      analogWrite(PanelLED, j);    
    }     

    // set LEDs to default values                   
   analogWrite(LEDbtn0, 0);      // Proj is off
   analogWrite(LEDbtn1, 0);      // Wave if off
   analogWrite(LEDbtn2, LEDon);  // Sync is on 
   analogWrite(PanelLED, 0);     // Error-LED is off


  // Open Serial2 for Projector communication
  Serial2.begin(19200);  
  t = 50; //wait for serial port to open, max 5 seconds
  while (!Serial2) {
      delay(100);
      if ( (t--) == 0 ) {
        initOK=false;
        Serial.println(F("ERROR : Could not open serial port to projector!"));
        break;
      }
  } 

  if (initOK) Serial.println(F("Intit done.")); else Serial.println(F("Warning : Initialization errors !!"));
  
  // Start Projector via Serial2 interface, wait for Power on and do settings
  TurnProjectorOn();

  // show commands on host serial IF
  inputString="help";
  getCommand();
  inputString="";
  Serial.println(" ");

  // Setup PWM output for wavetable generator
  pinMode(PWM_OUT, OUTPUT);                   // Set PWM-Out pin (PWM-Pin D3 controlled by Timer 3 on MEGA)
  TCCR3B = TCCR3B & 0b11111000 | 1;           // set 31Khz as PWM frequency  
  analogWrite(PWM_OUT, 0);                    // output off
 
  // Timer4 Setup (controls the wavetable output)
  freq=30;
  fs = freq*wavetable_entries ; // output freq * 256 steps of wavetable give sample freq fs
  Ts = 1000000/fs;              // sample-time Ts=1/fs  default is 130us for 30Hz*256 (values in us)
  SetTimer4((int)Ts);           // Set Timer4 to  .. us
 
  // Pulse-sync-input from Projector : Enable interrupt when going from H->L
  pinMode(Proj_PulsePin, INPUT);  // or INPUT_PULLUP if signal is bad                            
  attachInterrupt(digitalPinToInterrupt(Proj_PulsePin), Proj_Pulse_Event, FALLING);  

  sei(); //allow interrupts

  Serial.println(F("\n\nEnd of Startup. \nMay the force be with you."));
  Serial.println("\n>");
  
} 


/* --------------------------------------------------------------------------------------
 MAIN LOOP (do some foreground stuff, but main action is handled via interrupts)
-------------------------------------------------------------------------------------- */
void loop() 
{ 
 int t;
   
    user_input();  // check and process buttons (-> in module FronPanelControls.ino)

    if (Serial.available() > 0) processInput(); // process serial commands (-> in module SerialCommand.ino)
    
    if (menu_timeout >0)  // handle menu timeout
    {
      menu_timeout--;
      if (menu_timeout == 0) show_main_page();  // clear menu after timeout and show main page
    }

   if (errorLED_timeout >0)  // handle error LED timeout
   {
     errorLED_timeout--;
     analogWrite(PanelLED, (errorLED_timeout*5));     // dim Error LED gradually
     if (errorLED_timeout == 0) analogWrite(PanelLED, 0);     // Error-LED is off
   }

    // calc current projector sync input
    if (!update_PulseProj)PeriodBetweenPulsesProj = 1000000;
    fps_proj=1000000*(1/(float)PeriodBetweenPulsesProj);   

    if (logfps)  // if enabled, dump some debug data to the host IF 
     {
          // output logging data:
          Serial.print(F("\tFproj="));
          Serial.print(fps_proj);
          Serial.print(F("\tTproj="));
          Serial.print(PeriodBetweenPulsesProj);
          Serial.print(F("\tFout ="));
          Serial.print(freq);
          Serial.print(F("\tTs  ="));
          Serial.print(Ts);
          Serial.print(F(" us "));
          Serial.print(F("\tPhase  ="));
          Serial.print(wavetable_start);
          Serial.print(F("\tvalve block  ="));
          Serial.print(valves_disable);
          Serial.print(F(" ... "));
          Serial.print(valves_enable);                 
          Serial.println(" ");
     } 
     
    delay(50);  // some delay (uses Timer0 !)

}



/* --------------------------------------------------------------------------------------
 Setup Timer4 to interrupt every ..us (using CTC Mode)
 Timer4 ticks are used for wavetable output and valve control
-------------------------------------------------------------------------------------- */
void SetTimer4(unsigned int us)
{
 
// Timer4 setup 
 TCCR4B = 0;                  // stop timer
 TCCR4A = 0;                  // disconnect OCR pins
 TCNT4  = 0;                  //initialize counter value to 0
 TIMSK4 = (1 << OCIE4A);      // enable timer compare interrupt

 // set reload value in us with 16MHz prescaler :
 OCR4A= (16 * us)-1;          // = (16*10^6 / 1) * (us*10^-6) - 1  = (16*us)-1;

 TCCR4B = (1 << CS40) | (1 << WGM42);   // turn on Timer4 (in CTC mode and prescaler = 1 = 16Mhz)
 
 Serial.print(F("\t timer4 set to us= "));  // for debug output only
 Serial.print(us);

}

/* --------------------------------------------------------------------------------------
 Timer4 Interrupt -> wavetable output and valve control
-------------------------------------------------------------------------------------- */
ISR(TIMER4_COMPA_vect)
{

  if (output_enabled)
  {
    // wavetable output control
    output=waveform[wavesample];       // read and output next wavetable entry to PWM pin
    analogWrite(PWM_OUT, output); 
    wavesample++;
     if (wavesample==wavetable_end) // end of wavetable readout section reached ?
     {
       if (proj_sync_mode) TCCR4B = 0;   // stop Timer in projector sync mode 
       wavesample=wavetable_start;    // next time re-start from readout start pos
       

     }
     if (wavesample==wavetable_entries)  wavesample=0;  // go back to start of table


     // Lightvalve control 
     valves++;
     if (valves == valves_enable)  //  lightvalve open (transparent)
     {
        digitalWrite(L293A1, 0);
        digitalWrite(L293A2, 0);
     }
     if (valves == valves_disable)  // (using alternating polarity) -> lightvalve blocking (opaque)
     {
        if (valve_alt)
        {
          digitalWrite(L293A1, 1);
          digitalWrite(L293A2, 0);
          valve_alt=false;
        }
        else
        {
          digitalWrite(L293A1, 0);
          digitalWrite(L293A2, 1);
          valve_alt=true;
        }

     }

     // -------  war == 64
     if (valves>=63) valves=0;  // re-start valve switch control after 1/4 cycle

  }  

} 


/* --------------------------------------------------------------------------------------
 Sync Puls Interrupt - triggered by falling edge of interrupt pin
 triggered by Color wheel sensor after one rotation = BRGBRG sequence typ each 8.3ms (120Hz)  
---------------------------------------------------------------------------------------- */
void Proj_Pulse_Event()
{
unsigned long mnow2;
    
   mnow2=micros();
   PeriodBetweenPulsesProj = mnow2 - LastMeasuredProj;           // get current period (time between 2 sync pulses) 
   LastMeasuredProj = mnow2;
   update_PulseProj = true; 
 
   divcount++;

   if (divcount > divider)    // after N color wheel pulses, re-start wavetable  (e.g. 4x 8.3ms = 33.3ms) 
   {
    divcount = 1;
    valves=0;
    TCNT4  = 0;
   if (output_enabled) TCCR4B = (1 << CS40) | (1 << WGM42);   // start wavetable player timer (enable Timer4)
   }

}

/* --------------------------------------------------------------------------------------
 Enable/disable Sin-Wave output (PWM pin) to amplifier (triggered by panel button or serial cmd)  
---------------------------------------------------------------------------------------- */
void WaveON(void)
{
      Serial.println(F("\n---  WAVE ON"));
      analogWrite(LEDbtn1, LEDon);          // light up WAVE button

      wavesample=wavetable_start;            // set start of table readout
      TCCR4B = (1 << CS40) | (1 << WGM42);   // start Timer4   
      output_enabled=true; 

      show_main_page();
      oled.setTextSize(1);          
      oled.setTextColor(WHITE, BLACK); 
      oled.setCursor(0, 53);        
      oled.println("          ON       ");
      oled.display();       

}

void WaveOFF(void)  
{
      Serial.println(F("\n---  WAVE OFF"));
      analogWrite(LEDbtn1, 0);           // turn off WAVE button LED    

      TCCR4B = 0;                           // stop Timer4 
      output_enabled=false;
      digitalWrite(L293A1, 0);             // set lightvalves to open 
      digitalWrite(L293A2, 0);    

      show_main_page();

}


/* --------------------------------------------------------------------------------------
 sets a new start for wavetable-readout = phase-shift 
---------------------------------------------------------------------------------------- */
void SetPhase(unsigned int ph)
{
        if (output_enabled && proj_sync_mode)  // during normal operation, change gradually to have a ...
        {            
            while(wavetable_start != ph)   // ...smooth transisiton until new setpoint reached (otherwise interupts the movement)
            {
              if (wavetable_start==0) 
              { 
                wavetable_start=wavetable_entries; 
                wavetable_end=wavetable_start-1;
              }
              else
              {
                wavetable_start--;  // going backwards leads to less interference
                wavetable_end=wavetable_start-1;
              }
                delay(8);
            }
        }else
        {
          wavetable_start=ph;
          if (wavetable_start==0) wavetable_end=256; else wavetable_end=wavetable_start-1; 
          wavesample=wavetable_start; 
        }
}

/* --------------------------------------------------------------------------------------
Volumetric Display Project
Host Serial Command Interface 
this module contains all serial interface functions for a connected PC 
MakerMac
May 23 
-------------------------------------------------------------------------------------- */

/* --------------------------------------------------------------------------------------
Process Input -> Called from main() when serial characters have been received
-------------------------------------------------------------------------------------- */
void processInput() 
{
  while (Serial.available())   // process all characters in input buffer received 
  {
    char inChar = (char)(Serial.read());  // read next character
    if (inChar == '\n')                   // Line-Feed received ?
       getCommand();                      // yes, commandline complete -> process command
    else
    {
       inputString += inChar;             // no, add chat to inputString 
       Serial.print(inChar);              // Echo 
    }
  }
}

/* --------------------------------------------------------------------------------------
Process Commands - evaluate and execute received commands
-------------------------------------------------------------------------------------- */
void getCommand()  
{
   String paramString = "";         // Parameters
   int len = inputString.length();  // length of commandline
   int s,md,t;
   logfps=false;  // stop logfps output if enabled

       
    // --------------------------------------
    // helpscreen
    if (inputString.startsWith("help"))
    {
        Serial.println("");
        Serial.println(F("available commands :"));
        Serial.println(F("help           ...lists all commands"));
        Serial.println(F("on/off         ...turn wave output ON or OFF "));
        Serial.println(F("mode [N]       ...sets mode to proj_sync (0) or continous (1) "));
        Serial.println(F("log            ...logs values (until next CR)"));
        Serial.println(F("freq [N]       ...sets frequency "));
        Serial.println(F("div [N]        ...sets divider "));
        Serial.println(F("von  [N]       ...Lightvalve on position or 256=Valves OFF "));
        Serial.println(F("voff [N]       ...Lightvalve off position  "));
        Serial.println(F("shift [N]      ...shift wavetable start by N samples "));
        Serial.println(F("skip           ...skip one wheel sync (to find startpos) "));
        Serial.println(F("proj status    ...shows projector status info"));
        Serial.println(F("3d on/off      ...set projector SBS mode on or off"));
        Serial.println(F("proj [on/off]  ...switches projector on/off "));

 
    }   
      
    // --------------------------------------
    // wave output ON/OFF
    if (inputString.startsWith("on"))
          WaveON();
    if (inputString.startsWith("off"))
          WaveOFF();

    // --------------------------------------
    // set mode (0=proj sync ; 1=free running)
    if (inputString.startsWith("mode"))
    {
   
      paramString = inputString.substring(5,len);
      md=paramString.toInt();
      if (md == 0)  // proj sync mode
      {  
         proj_sync_mode=true; 
         analogWrite(LEDbtn2, LEDon);  // light up SYNC button
         Serial.println(F("Mode 0 (SYNC) enabled"));
      }
      else if (md == 1)  // free running mode
      {
         proj_sync_mode=false; 
         wavesample=0;
         TCCR4B = (1 << CS40) | (1 << WGM42);   // start Timer4   
         output_enabled=true;
         analogWrite(LEDbtn2, 0);  // SYNC button off      
         Serial.println(F("Mode 1 (free running) enabled"));
      }
      else
      {
        Serial.println(F(" error, invalid  value !"));
      }
    }


    
    // --------------------------------------
    // print logfps information
    if (inputString.startsWith("log"))
    {
      Serial.println(F("\n--- start logging values :"));
      logfps = true;
    }
    

    // --------------------------------------
    // skip one wheelsync
    if (inputString.startsWith("skip"))
    {
      Serial.println(F("\n--- skipping one wheel sync pulse"));
      divcount--;
    }

    // --------------------------------------
    // set divider
    if (inputString.startsWith("freq"))
    {
      TCCR4B = 0;                           // stop Timer4 
      output_enabled=false;
      
      paramString = inputString.substring(5,len);
      freq=paramString.toInt();
      if (freq >0)
      {     
        wavesample=0;
        
        Serial.print(F("\n--- freq  ="));
        Serial.print(freq);
        fs = freq*wavetable_entries ; // output freq * 256 steps of wavetable give sample freq fs
        Ts = 1000000/fs;              // sample-time Ts=1/fs  e.g. 39us for 100Hz*256 (values in us)

        SetTimer4((int)Ts);  // Set Timer to  .. us
        Serial.print(" Ts  =");
        Serial.print(Ts);
        Serial.print(F(" us "));

        Serial.println(F(" ...ok"));
        output_enabled=true;
      }
      else
      {
        Serial.println(F(" error, invalid  value !!"));
      }
    }

    // --------------------------------------
    // set divider
    if (inputString.startsWith("div"))
    {
      paramString = inputString.substring(4,len);
      divider=paramString.toInt();
      if (divider >0)
      {     
        Serial.print(F("\n--- set div ="));
        Serial.print(divider);
        Serial.println(F(" ...ok"));
      }
      else
      {
        Serial.println(F(" error, invalid divider value !!"));
        divider = 4;
      }
    }
    
    // --------------------------------------
    // shift
    if (inputString.startsWith("shift"))
    {
      paramString = inputString.substring(6,len);
      t=paramString.toInt();
      if (t >=0)
      { 
        Serial.print(F("\n--- shift wavetable start to "));
        Serial.print(t);
        SetPhase(t);
        Serial.println(F(" ...ok"));

      }
      else
      {
        Serial.println(F(" error, invalid value !!"));
      }
    }
    
    // --------------------------------------
    // set Lightvalves
    if (inputString.startsWith("von"))
    {
      paramString = inputString.substring(4,len);
      s=paramString.toInt();
      if ((s >0) && (s<300))
      {     
        Serial.print(F("\n--- valve on ="));
        Serial.print(s);
        Serial.println(F(" ...ok"));
        valves_enable=s;
        if (s>=256) 
        { 
          Serial.print(F("\n--- valves OFF"));

        digitalWrite(L293A1, 0);
        digitalWrite(L293A2, 0);    
        }
      }
      else
      {
        Serial.println(F(" error, invalid value !!"));
      }
    }

   if (inputString.startsWith("voff"))
    {
      paramString = inputString.substring(5,len);
      s=paramString.toInt();
      if ((s >0) && (s<300))
      {     
        Serial.print(F("\n--- valve off ="));
        Serial.print(s);
        Serial.println(F(" ...ok"));
        valves_disable=s;
      }
      else
      {
        Serial.println(F(" error, invalid value !!"));
      }
    }

    // --------------------------------------
    // projector commands
    if (inputString.startsWith("proj status"))
    {
      Serial.println(F("\n--- Projector Status information:"));
      GetProjectorPowerStatus();
      projcommand="*modelname=?#";
      DoProjectorCommand();
      Serial.print(F("Model ")); Serial.println(projresponse);
      projcommand="*ltim=?#";
      DoProjectorCommand();
      Serial.print(F("Lamp hours ")); Serial.println(projresponse);
      projcommand="*lampm=?#";
      DoProjectorCommand();      
      Serial.print(F("Lamp mode ")); Serial.println(projresponse);
      projcommand="*3d=?#";
      DoProjectorCommand();      
      Serial.print(F("3d mode ")); Serial.println(projresponse);
 
    }

    if (inputString.startsWith(F("proj off")))
    {
      Serial.println(F("\n--- Switching projector off, please wait..."));
      TurnProjectorOff();
     }
    if (inputString.startsWith("proj on"))
    {
      Serial.println(F("\n--- Projector restart"));
      TurnProjectorOn();
    }
    
    // 3d mode
    if (inputString.startsWith("3d on"))
    {
      Serial.println(F("\nSetting 3D Mode to Side-by-side"));
      projcommand="*3d=sbs#";
      DoProjectorCommand();
      Serial.println("Response='"+projresponse+"'");
    }
    if (inputString.startsWith("3d off"))
    {
      Serial.println(F("\nDisable 3D Mode"));
      projcommand="*3d=off#";
      DoProjectorCommand();
      Serial.println("Response='"+projresponse+"'");

    }
    // print power state
    if (inputString.startsWith("power?"))
    {
      GetProjectorPowerStatus();
    }

    // --------------------------------------
    // ready for next command
    Serial.println(F("\n>"));
    inputString = "";     
 
}

/*
Volumetric Display Project
Remote control projector functions using 2nd serial interface

Projector Serial Interface (for remote control of W10170 Projector via Software UART)

Maker Mac 
May  2023

*/



/* --------------------------------------------------------------------------------------
DoProjectorCommand
Sends a command via AltSerial UART and waits for response message ending with # from the
W1070 projector (see Benq "Projector RS232 Command Guide" for details)
command to be sent is stored in "projcommand"
response from projector will be stored in "projresponse" 
in case of known errors, the responses are :
*Illegal format
*Unsupported item
*Block item
!Timeout
-------------------------------------------------------------------------------------- */
void DoProjectorCommand()
{


  char inChar;
  String ReceiveLine;
  bool complete=false;
  int rechash=0;
  unsigned int i=0 , timeout=100000;  

  projresponse="";
  while(Serial2.available()) inChar = (char)(Serial2.read());      // wait for silence
  Serial2.print('\r'+projcommand+'\r');  // send out command in format : <CR>COMMAND<CR>
  while(!complete)   // process response
  {   

      if (Serial2.available())   // process all characters in input buffer received 
      {
        inChar = (char)(Serial2.read());  // read next character until delimiter
 //       Serial.print(inChar);                // Echo everthing on built-in serial for debug 
        if (inChar == '#')                   // "#"" = end of command received ?
        {
          rechash++;                         // count the #s...
          if (rechash==2) complete=true;     // first "#" is end of command Echo, 2nd "#" means message completed 
        }
        else
        {
           if ((rechash>0) && (inChar>31)) projresponse += inChar;   // after Echo, add char to responseString (no control chars)           
        }
      }
    i++;
    if (i>timeout) 
    {
//      Serial.println("ERROR-TIMEOUT");  // for debug only
      complete=true;
      projresponse="!Timeout";
    }
  }


}


/* --------------------------------------------------------------------------------------
Gets the power status from projector 
returns: 1=powered on ; 2=not yet powered on; 3=off ; 4=no response; 5=comm error
-------------------------------------------------------------------------------------- */
int GetProjectorPowerStatus(void)
{
 //     Serial.println(F("\nGetting projector power status"));  // for debug only

      projcommand="*pow=?#";  // ask projector about power status
      DoProjectorCommand();
      // process known responses 
      if (projresponse.startsWith("*POW=ON"))
      {
        Serial.println(F("Projector is switched ON"));
        projector_on=true;
        projector_off=false;
        return 1;
      }
      else if (projresponse.startsWith("*Block item"))
      {
        Serial.println(F("Projector is NOT READY (yet)"));
        projector_on=false;
        return 2;
      }
      else if (projresponse.startsWith("*POW=OFF"))
      {
        Serial.println(F("Projector is switched OFF"));
        projector_on=false;
        projector_off=true;
        return 3;
      }
      else if (projresponse.startsWith("!Timeout"))
      {
        Serial.println(F("Projector is not responding -> No AC Power !?"));
        projector_on=false;
        return 4;
      }
      else
      {
       Serial.println("Error - unexpected response:"+projresponse);       
       return 5;
      }

}


/* --------------------------------------------------------------------------------------
 Turn on Projector 
attempts to turn on power via serial connection
-------------------------------------------------------------------------------------- */

void  TurnProjectorOn(void)
{
  int i,j, tries=0;
  char inChar;

  // message on OLED
  oled.setTextSize(1);          
  oled.setTextColor(WHITE, BLACK);     
  oled.setCursor(0, 52);        
  oled.println("Starting Projector..."); 
  oled.display();   
  analogWrite(PanelLED, 0);    // turn off ERROR LED
  errorLED_timeout=0;      

  while (Serial.available() > 0) inChar = (char)(Serial.read());  // make sure all chars received

  Serial.println(F("\nPower sequence start. Getting projector power status - for abort press any key")); // gets power status from projector 
  i=GetProjectorPowerStatus();
  while ((i!=1) && (tries<20))  // tries up to 120 times (1 each second) until power on
  {
    Serial.print(tries+1); Serial.print("/20 ");
    i=GetProjectorPowerStatus();
    if (i==3) // if Power=OFF, try to switch on
    {
       Serial.println(F("trying to switch on... "));
       delay(200);
       projcommand="*pow=on#";  
       DoProjectorCommand();
       Serial.println("response:"+projresponse);
       delay(100);
    }
    tries++;
    delay(500);
    
    oled.fillRect((tries-1)*6, 60, 6, 4, WHITE); // draw progress bar
    oled.display();
          
    analogWrite(LEDbtn0, LEDon);   // flash ON Button LED
    delay(500);
    analogWrite(LEDbtn0, 0);
    
    if ((Serial.available() > 0) || (! ss.digitalRead(SS_SWITCH)))  {     // abort when any char was received or encoder button pressed
      inChar = (char)(Serial.read());
      Serial.println("aborted...");
      tries=21;
      oled.setTextSize(1);          
      oled.setCursor(0, 52);        
      oled.println("Proj start aborted..."); 
      oled.display(); 
      analogWrite(PanelLED, LEDon);    // turn on ERROR LED
      errorLED_timeout=ERRORTIME;      // start Error LED timeout

    }
  }
  if (tries==20) // timeout ...no response from projector after 20 sec
  {
    Serial.println(F("giving up..."));  
    oled.setTextSize(1);          
    oled.setCursor(0, 52);        
    oled.println("ERROR:PROJ TIMEOUT !!"); 
    oled.display(); 
    analogWrite(PanelLED, LEDon);    // turn on ERROR LED
    errorLED_timeout=ERRORTIME;      // start Error LED timeout
  }
  else { 
     if (projector_on)  // succes -> projector responded "power on"...
     {
      oled.setTextSize(1);          // text size
      oled.setCursor(0, 52);        // position to display
      oled.println("Power on OK...       "); // text to display
      oled.display();   // show 
      analogWrite(LEDbtn0, LEDon);   // light ON Button LED

      tries=0;
      while ((!projector_sbs) && (tries<20))  // tries up to 20 times (1 each second) to set mode
      {
       projcommand="*3d=sbs#";  // ...now put projector in side-by-side more for 120Hz input
       DoProjectorCommand();
       Serial.println("response:"+projresponse);
       if (projresponse.startsWith("*3D=SBS")) // process response
       {
        Serial.println(F("OK - Projector on and in SBS mode.")); 

        oled.setTextSize(1);          
        oled.setCursor(0, 52);        
        oled.println("OK. Proj ON + SBS    "); 
        oled.display();    

        projector_sbs=true;
       }
       else if (projresponse.startsWith("*Block item"))
       {
        Serial.println(F("Projector is NOT READY (yet)"));
        delay(1000);
       }
       tries++;
       if (tries==20) // timeout after 20sec
       {
         Serial.println(F("ERROR - Projector could NOT be set to SBS mode!"));
          oled.setTextSize(1);          
          oled.setCursor(0, 52);        
          oled.println("ERROR:SBS MODE FAIL !"); 
          oled.display();  
          analogWrite(PanelLED, LEDon);    // turn on ERROR LED
          errorLED_timeout=ERRORTIME;      // start Error LED timeout  
       }
      }
     }


     Serial.println(F("ready."));
  }

  oled.fillRect(0, 60, 127, 4, BLACK); // clear progress bar
  oled.display();    

}

// Turn OFF
void  TurnProjectorOff(void)
{
  int i,j, tries=0;
  
  // message on OLED
  oled.setTextSize(1);          
  oled.setTextColor(WHITE, BLACK);     
  oled.setCursor(0, 52);        
  oled.println("Turning off Projector "); 
  oled.display();   

  Serial.println(F("\nGetting projector power status")); // gets power status from projector 
  i=GetProjectorPowerStatus();
  while ((i!=3) && (tries<256))  // tries up to 256 times (1 each second = 4 minutes) until power off
  {
    Serial.print(tries+1); Serial.print("/256 ");
    i=GetProjectorPowerStatus();
    if (i==1) // if Power=ON, try to switch off
    {
       Serial.println(F("switching off..."));
       delay(200);
       projcommand="*pow=off#";  
       DoProjectorCommand();
       Serial.println("response:"+projresponse);
       delay(100);
    }
    tries++;
    delay(500);

    if (tries<128)  // draw progress bar
      oled.fillRect(tries, 60, 1, 4, WHITE); 
    else
      oled.fillRect(256-tries, 60, 1, 4, BLACK); 
    oled.display();

    analogWrite(LEDbtn0, LEDon);   // flash ON Button LED
    delay(500);
    analogWrite(LEDbtn0, 0);

  }
  if (tries==256) // timeout ?
  {
    Serial.println(F("giving up..."));  

    oled.setTextSize(1);          
    oled.setCursor(0, 52);        
    oled.println("ERROR:PROJ TIMEOUT !!"); 
    oled.display(); 
    analogWrite(PanelLED, LEDon);    // turn on ERROR LED
    errorLED_timeout=ERRORTIME;      // start Error LED timeout     
  }
  else  // no
  { 
     if (projector_off)  // succes -> projector responded "power off"...
     {
       Serial.println(F("OK - Projector switched off.")); 
       oled.setTextSize(1);          
       oled.setCursor(0, 52);        
       oled.println("OK..Projector now off"); 
       oled.display();    
       projector_sbs=false;
       analogWrite(PanelLED, 0);    
       analogWrite(LEDbtn0, 0);
       errorLED_timeout=0;      
     }

     Serial.println(F("ready."));
  }

  oled.fillRect(0, 60, 127, 4, BLACK); // clear progress bar
  oled.display();    

}

/*
Volumetric Display Project
front panel elements : OLED display, rotary knob and buttons
Maker Mac 
June 2023
*/
 


/* --------------------------------------------------------------------------------------
 Called from main() -> check user Interface (buttons, rotary encoder on front panel)
-------------------------------------------------------------------------------------- */
void user_input()
{
  int32_t tmp0_position, tmp_position, t0b, t1b;

  // check buttons 
  if (digitalRead(Button0) == 0)  // ON/OFF button
  {
    Serial.println(F("ON/OFF button pressed."));
    if (projector_on) 
      TurnProjectorOff();
    else
      TurnProjectorOn();
  }

  if (digitalRead(Button1) == 0)  // WAVE button
  {
     Serial.println(F("WAVE button pressed."));
     if (!output_enabled)   // if not enabled, turn on
       WaveON();
     else                       
       WaveOFF();           // turn off 

  }

  if (digitalRead(Button2) == 0)  // SYNC button
  {

    t0b=micros();
    while(digitalRead(Button2) == 0) // wait until released
    {
      t1b=micros()-t0b;
      if (t1b>300000 && proj_sync_mode) analogWrite(LEDbtn2, 0);  // SYNC button off  
      if (t1b>300000 && !proj_sync_mode) analogWrite(LEDbtn2, LEDon);  // SYNC button on  
    }
//    Serial.print("tb=");     Serial.println(t1b);
    if (t1b>300000) // evaluate press duration
    {
     Serial.println(F("SYNC button LONG pressed."));

     if (!proj_sync_mode)     // if not in proj sync mode
      {  
         proj_sync_mode=true;  // set sync to on
         Serial.println("Mode 0 (SYNC) enabled");
         analogWrite(LEDbtn2, LEDon);  // light up SYNC button LED
      }
      else                     // else enter free running mode
      {
         proj_sync_mode=false; 
         wavesample=0;
         TCCR4B = (1 << CS40) | (1 << WGM42);   // start Timer4   
         Serial.println("Mode 1 (free running) enabled");
         analogWrite(LEDbtn2, 0);  // SYNC button off         
      }


    }else
    {
     analogWrite(LEDbtn2, 0);  // SYNC button off         
     Serial.println(F("SYNC button short pressed."));
     Serial.println(F("\n--- skipping one wheel sync pulse"));
     divcount--;
     analogWrite(LEDbtn2, LEDon);  // light up SYNC button LED
    }





  }


  // handle rotary encoder 
  int32_t new_position = ss.getEncoderPosition();  // get actual encoder position
  if (encoder_position != new_position)    // encoder changed ?
  {
    sspixel.setPixelColor(0, 255,255,0);  // yes, set Neopixel to yellow
    sspixel.show();
    
    if (new_position < encoder_position)  // increment menu pos
    {
      menu_position++;
      if (menu_position > menusize) menu_position=0;
    }
    if (new_position > encoder_position) // decrement menu pos
    {
      menu_position--;
      if (menu_position < 0) menu_position=menusize;
    }
    showmenu();      // show updated menu  
    encoder_position = new_position;      // save position 

  }  

  // check encoder button
  if (! ss.digitalRead(SS_SWITCH))         // Encoder button pressed ?
  {
    sspixel.setPixelColor(0, 0,255,255);  // Yes, set Neopixel to cyan
    sspixel.show();

    Serial.print("enter menu "); Serial.println(menu_position);

    while (! ss.digitalRead(SS_SWITCH));  // wait until button is released

    switch(menu_position)    // activate selected menu iten
    {  
      case 0:               // Show Status information
        showstatus();
        menu_timeout = 0;  // prevent to show main page
       break;
      case 1:               // Set Freq
        adjustfreq();                   
       break;
      case 2:               // Set Phase
        adjustphase();
       break;
      case 3:               // LV open pos
        adjustLVopen();    
       break;
      case 4:               // LV close pos
        adjustLVclose();
       break;
      case 5:  // (re-)set SBS mode
        oled.clearDisplay(); 
        oled.setTextSize(2); 
        oled.setCursor(0, 10);        
        oled.println("Set Mode:");
        oled.setCursor(0, 30);        
        oled.println("SBS");
        oled.setTextColor(WHITE, BLACK);   
        oled.display();                
        Serial.println(F("\nSetting 3D Mode to Side-by-side"));
        projcommand="*3d=sbs#";
        DoProjectorCommand();
        Serial.println("Response='"+projresponse+"'");
       break;
      case 6:  // Switch Input
        if (proj_input == 1)
        {
          oled.clearDisplay(); 
          oled.setTextSize(2); 
          oled.setCursor(0, 10);        
          oled.println("Set Input:");
          oled.setCursor(0, 30);        
          oled.println("int(HDMI1)");
          oled.setTextColor(WHITE, BLACK);   
          oled.display();                    
          Serial.println(F("\nSet proj input to HDMI"));
          projcommand="*sour=hdmi#";
          DoProjectorCommand();
          Serial.println("Response='"+projresponse+"'");
          proj_input=2;
        } else
       {
          oled.clearDisplay(); 
          oled.setTextSize(2); 
          oled.setCursor(0, 10);        
          oled.println("Set Input:");
          oled.setCursor(0, 30);        
          oled.println("ext(RGB)");
          oled.setTextColor(WHITE, BLACK);   
          oled.display();                    
          Serial.println(F("\nSet proj input to RGB(PC)"));
          projcommand="*sour=RGB#";
          DoProjectorCommand();
          Serial.println("Response='"+projresponse+"'");
          proj_input=1;
        }
       break;
      default:
       Serial.println("unknown menu option");
      break;
      
    }
  }
}

// Menu Status : show some status information
void showstatus()
{
        oled.clearDisplay(); // clear display
        oled.setTextSize(1);          
        oled.setTextColor(WHITE, BLACK); 
        oled.setCursor(0, 10);        
        oled.println("        STATUS : ");
        oled.setCursor(0, 20);        
        oled.print("Proj fw = "); oled.print(fps_proj); oled.println(" Hz  ");             
        oled.setCursor(0, 30);        
        oled.print("Phase   = "); oled.println(wavetable_start);             
        oled.setCursor(0, 40);        
        oled.print("LV open = "); oled.println(valves_disable);             
        oled.setCursor(0, 50);        
        oled.print("LV close= "); oled.println(valves_enable);             
        oled.setCursor(95, 55);        
        oled.println("(1/1)");
        oled.display();          
}

// Menu Freq : adjust frequency (6-50Hz) using encoder knob
void adjustfreq()
{
        oled.clearDisplay(); 
        oled.setTextSize(2); 
        oled.setCursor(0, 10);        
        oled.println("Set Freq:");
        oled.setTextColor(WHITE, BLACK);   
        oled.display();          
        
        int32_t tmp0_position = ss.getEncoderPosition();  // get actual encoder position
        int freq_old=freq;
        while (ss.digitalRead(SS_SWITCH))  // adjust until button is pressed
        {
          oled.setCursor(0, 30);        
          oled.print(freq); oled.println(" Hz  ");
          oled.display();          

          int32_t tmp_position = ss.getEncoderPosition();
          if (tmp0_position > tmp_position) freq++;
          if (tmp0_position < tmp_position) freq--;
          if (freq<6) freq=6;
          if (freq>50) freq=50;
          if (freq_old != freq)
          {
            fs = freq*wavetable_entries ; // output freq * 256 steps of wavetable give sample freq fs
            Ts = 1000000/fs;              // sample-time Ts=1/fs  default is 130us for 30Hz*256 (values in us)
            SetTimer4((int)Ts);           // Set Timer4 to  .. us
            Serial.print(" freq  =");
            Serial.print(freq);
            Serial.print(" -> Ts  =");
            Serial.print(Ts);
            Serial.println(F(" us "));

          }
          freq_old=freq;
          tmp0_position=tmp_position;
           
        }
        while (! ss.digitalRead(SS_SWITCH));  // wait until button is released
 
}

// Menu Phase : adjusts phase (wavetable_start 0-255) using Encoder knob
void adjustphase()
{

        oled.clearDisplay(); 
        oled.setTextSize(2); 
        oled.setCursor(0, 10);        
        oled.println("Set Phase:");
        oled.setTextColor(WHITE, BLACK);   
        oled.display();          
        int32_t tmp0_position = ss.getEncoderPosition();  // get actual encoder position
        int start_old=wavetable_start;
        int pha = start_old;
        while (ss.digitalRead(SS_SWITCH))  // adjust until button is pressed
        {
          oled.setCursor(0, 30);        
          oled.print(wavetable_start); oled.println("   ");
          oled.display();          

          int32_t tmp_position = ss.getEncoderPosition();
          if (tmp0_position > tmp_position) pha++;
          if (tmp0_position < tmp_position) pha--;
          if (pha<0) pha=255;
          if (pha>255) pha=0;
          if (start_old != pha)
          {
              Serial.print(F("\n--- shift wavetable start to "));
              Serial.print(pha);
              SetPhase(pha);
              Serial.println(F(" ...ok"));
          }
          start_old=pha;
          tmp0_position=tmp_position;
        }
        while (! ss.digitalRead(SS_SWITCH));  // wait until button is released

}

// Menu LVopen : adjusts lightvalve open position (0-64) using Encoder knob
void adjustLVopen()
{
        oled.clearDisplay(); 
        oled.setTextSize(2); 
        oled.setCursor(0, 10);        
        oled.println("Set LV open:");
        oled.setTextColor(WHITE, BLACK);   
        oled.display();          
        int32_t tmp0_position = ss.getEncoderPosition();  // get actual encoder position
        int valves_old=valves_disable;
        while (ss.digitalRead(SS_SWITCH))  // adjust until button is pressed
        {
          oled.setCursor(0, 30);        
          oled.print(valves_disable); oled.println("   ");
          oled.display();          

          int32_t tmp_position = ss.getEncoderPosition();
          if (tmp0_position > tmp_position) valves_disable++;
          if (tmp0_position < tmp_position) valves_disable--;
          if (valves_disable<0) valves_disable=0;
          if (valves_disable>63) valves_disable=63;
          if (valves_old != valves_disable)
          {
              Serial.print(F("\n--- set valves disable = "));
              Serial.print(valves_disable);
          }
          valves_old=valves_disable;
          tmp0_position=tmp_position;
        }
        while (! ss.digitalRead(SS_SWITCH));  // wait until button is released

}

// Menu LVclose : adjusts lightvalve block position (0-64) using Encoder knob
void adjustLVclose()
{
        oled.clearDisplay(); 
        oled.setTextSize(2); 
        oled.setCursor(0, 10);        
        oled.println("Set LV close:");
        oled.setTextColor(WHITE, BLACK);   
        oled.display();          
        int32_t tmp0_position = ss.getEncoderPosition();  // get actual encoder position
        int valves_old=valves_enable;
        while (ss.digitalRead(SS_SWITCH))  // adjust until button is pressed
        {
          oled.setCursor(0, 30);        
          oled.print(valves_enable); oled.println("   ");
          oled.display();          

          int32_t tmp_position = ss.getEncoderPosition();
          if (tmp0_position > tmp_position) valves_enable++;
          if (tmp0_position < tmp_position) valves_enable--;
          if (valves_disable<0) valves_enable=0;
          if (valves_disable>63) valves_enable=63;
          if (valves_old != valves_enable)
          {
              Serial.print(F("\n--- set valves enable = "));
              Serial.print(valves_enable);
          }
          valves_old=valves_enable;
          tmp0_position=tmp_position;
        }
        while (! ss.digitalRead(SS_SWITCH));  // wait until button is released

}


// show menu as rotating bar on the OLED display
void showmenu()
{
  oled.clearDisplay(); // clear display

  // show previous menu entry
  signed int l=menu_position-1;
  if (l<0) l=menusize;
  oled.setTextSize(2);          // text size
  oled.setTextColor(WHITE, BLACK);     // text color (normal)
  oled.setCursor(0, 10);        // position to display
  oled.println(menuitem[l]); // text to display

  // show currently active menu entry
  l++;
  if (l>menusize) l=0;
  oled.setTextColor(BLACK, WHITE);     // text color (highlighted)
  oled.setCursor(0, 25);        // position to display
  oled.println(menuitem[l]); // text to display

  // show next menu entry
  l++;
  if (l>menusize) l=0;
  oled.setTextColor(WHITE, BLACK);     // text color (normal)
  oled.setCursor(0, 40);        // position to display
  oled.println(menuitem[l]); // text to display
 
  oled.display();   // show on OLED

  menu_timeout = MENUTIME;  // restart menu time-out timer 
  
}

// Show main display on OLED (if menu is turned off)
void show_main_page()
{
  oled.clearDisplay(); // clear display
  drawbitmap();  // show rebel bitmap

  oled.setTextSize(1);          
  oled.setTextColor(WHITE, BLACK); 
  oled.setCursor(0, 53);        
  oled.println("        READY");
  oled.display();   
  
  sspixel.setPixelColor(0, 0,0,0);  // switch off Neopixel
  sspixel.show();

}

/* --------------------------------------------------------------------------------------
 draws a bitmap on the OLED display (the "rebel" logo) 
---------------------------------------------------------------------------------------- */
void drawbitmap(void) 
{
  oled.clearDisplay();
  oled.drawBitmap(
    (oled.width()  - LOGO_WIDTH ) / 2,
    (oled.height() - LOGO_HEIGHT) / 2,
    rebel_logo, LOGO_WIDTH, LOGO_HEIGHT, 1);
  oled.display();
}

// Wave table for one sine wave cycle 
static  int  waveform[]  ={  
0    , 
0    , 
0    , 
0    , 
0    , 
0    , 
1    , 
1    , 
2    , 
2    , 
3    , 
3    , 
4    , 
5    , 
6    , 
7    , 
8    , 
9    , 
10    , 
11    , 
13    , 
14    , 
16    , 
17    , 
19    , 
20    , 
22    , 
24    , 
26    , 
28    , 
30    , 
32    , 
34    , 
36    , 
38    , 
40    , 
43    , 
45    , 
47    , 
50    , 
52    , 
55    , 
57    , 
60    , 
63    , 
65    , 
68    , 
71    , 
74    , 
77    , 
79    , 
82    , 
85    , 
88    , 
91    , 
94    , 
97    , 
100    , 
103    , 
106    , 
110    , 
113    , 
116    , 
119    , 
122    , 
125    , 
128    , 
131    , 
134    , 
138    , 
141    , 
144    , 
147    , 
150    , 
153    , 
156    , 
159    , 
162    , 
165    , 
168    , 
171    , 
174    , 
177    , 
180    , 
182    , 
185    , 
188    , 
191    , 
193    , 
196    , 
199    , 
201    , 
204    , 
206    , 
208    , 
211    , 
213    , 
215    , 
218    , 
220    , 
222    , 
224    , 
226    , 
228    , 
230    , 
232    , 
233    , 
235    , 
237    , 
238    , 
240    , 
241    , 
242    , 
244    , 
245    , 
246    , 
247    , 
248    , 
249    , 
250    , 
250    , 
251    , 
252    , 
252    , 
253    , 
253    , 
253    , 
254    , 
254    , 
254    , 
254    , 
254    , 
254    , 
254    , 
253    , 
253    , 
252    , 
252    , 
251    , 
251    , 
250    , 
249    , 
248    , 
247    , 
246    , 
245    , 
244    , 
243    , 
241    , 
240    , 
238    , 
237    , 
235    , 
234    , 
232    , 
230    , 
228    , 
226    , 
224    , 
222    , 
220    , 
218    , 
216    , 
214    , 
211    , 
209    , 
207    , 
204    , 
202    , 
199    , 
197    , 
194    , 
191    , 
189    , 
186    , 
183    , 
180    , 
177    , 
175    , 
172    , 
169    , 
166    , 
163    , 
160    , 
157    , 
154    , 
151    , 
148    , 
144    , 
141    , 
138    , 
135    , 
132    , 
129    , 
126    , 
123    , 
120    , 
116    , 
113    , 
110    , 
107    , 
104    , 
101    , 
98    , 
95    , 
92    , 
89    , 
86    , 
83    , 
80    , 
77    , 
74    , 
72    , 
69    , 
66    , 
63    , 
61    , 
58    , 
55    , 
53    , 
50    , 
48    , 
46    , 
43    , 
41    , 
39    , 
36    , 
34    , 
32    , 
30    , 
28    , 
26    , 
24    , 
22    , 
21    , 
19    , 
17    , 
16    , 
14    , 
13    , 
12    , 
10    , 
9    , 
8    , 
7    , 
6    , 
5    , 
4    , 
4    , 
3    , 
2    , 
2    , 
1    , 
1    , 
1    , 
0    
};

// 'rebel_logo3', 128x64px
const unsigned char rebel_logo [] PROGMEM = {
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x81, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x03, 0xe0, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x07, 0xe0, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x0f, 0xf0, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x1f, 0xf8, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xe0, 0x1f, 0xf8, 0x07, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xe0, 0x0f, 0xf8, 0x03, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xc0, 0xef, 0xf3, 0x03, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x81, 0xef, 0xf7, 0x81, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x81, 0xff, 0xff, 0xc1, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x01, 0xff, 0xff, 0x80, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x00, 0xff, 0xff, 0x00, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x00, 0x7f, 0xfe, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x3f, 0xfc, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x1f, 0xf8, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x0f, 0xf8, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x0f, 0xf0, 0x00, 0x3f, 0x80, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x01, 0xfe, 0x00, 0x07, 0xf0, 0x00, 0x3f, 0x80, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x01, 0xfe, 0x00, 0x07, 0xe0, 0x00, 0x3f, 0x80, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x01, 0xfe, 0x00, 0x07, 0xe0, 0x00, 0x3f, 0xc0, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x01, 0xfe, 0x00, 0x07, 0xe0, 0x00, 0x3f, 0xc0, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x03, 0xfe, 0x00, 0x07, 0xe0, 0x00, 0x3f, 0xc0, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x03, 0xfe, 0x00, 0x07, 0xe0, 0x00, 0x7f, 0xc0, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x03, 0xfe, 0x00, 0x07, 0xe0, 0x00, 0x7f, 0xc0, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0x00, 0x07, 0xe0, 0x00, 0x7f, 0xc0, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0x00, 0x07, 0xf0, 0x00, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0x00, 0x0f, 0xf0, 0x00, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0x80, 0x1f, 0xf8, 0x01, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xc0, 0x1f, 0xfc, 0x03, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xe0, 0x7f, 0xfe, 0x07, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

Tools for the "DIY Volumetric Display" project

Assembly x86

This is a set of tools for the "DIY Volumetric Display" project:
These software tools are made for this project exclusively. They run only on Windows (any recent version is ok). Important : They are not fully tested and may not be perfect ! So use them at your own risk.
No installation is required, just copy the entire contents of the zip archive into a directory.
1. VolDispSlicer.exe
2. VolDisPlayer.exe
3. VolDisLayerConfig.exe
more information on how to use the tools is included in the archive

No preview (download only).

Credits

mac70

5 projects • 27 followers

Star Wars Inspired DIY Volumetric Display

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

Introduction

1) A fast projector

1.1 Modification of a standard DLP projector

1.2 Frame sequence analysis

1.3 Adding a shutter

2) The swept volume

2.1 Destroying speakers

2.2 Flexible structures

3) Electronics

3.1 analyze the projector timing

3.2 drive the voice coils

3.2 control the shutter

4) Software

4.1 Calibration tool

4.2 Slicer

4.3 Player

4.4 Arduino Script

5) Star Wars inspired housing

Conclusion

Custom parts and enclosures

STL files

Schematics

schematics

Code

Volumetric14.ino - the main module

SerialCommand.ino

ProjectorRemote.ino

FrontPanelControls.ino

sinus.h

rebel_logo.h

Tools for the "DIY Volumetric Display" project

Credits

mac70

Comments

Embed the widget on your own site

Star Wars Inspired DIY Volumetric Display

Star Wars Inspired DIY Volumetric Display

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

Introduction

1) A fast projector

1.1 Modification of a standard DLP projector

1.2 Frame sequence analysis

1.3 Adding a shutter

2) The swept volume

2.1 Destroying speakers

2.2 Flexible structures

3) Electronics

3.1 analyze the projector timing

3.2 drive the voice coils

3.2 control the shutter

4) Software

4.1 Calibration tool

4.2 Slicer

4.3 Player

4.4 Arduino Script

5) Star Wars inspired housing

Conclusion

Custom parts and enclosures

STL files

Schematics

schematics

Code

Volumetric14.ino - the main module

SerialCommand.ino

ProjectorRemote.ino

FrontPanelControls.ino

sinus.h

rebel_logo.h

Tools for the "DIY Volumetric Display" project

Credits

mac70

Comments

Related channels and tags