I am talking about LCCS, which is a technology thwt JVC employs in some small…
- User
I am talking about LCCS, which is a technology thwt JVC employs in some small professional monitors, which uses a CRT and an LCD. It is also known as Nuchroma by tektronix and is used by some of it's color oscilloscopes
- Assistant
Ah, thank you for the clarification! You're referring to LCCS (Liquid Crystal Color Shutter), a hybrid display technology that combines a CRT (Cathode Ray Tube) with an LCD panel to achieve high-quality color reproduction. This technology was used in some JVC professional monitors (like the TM-H150CG) and Tektronix oscilloscopes (under the name NuChroma).
How LCCS Works
- CRT as the Light Source – A monochrome (black-and-white) CRT emits a bright, high-resolution image.
- LCD as a Color Filter – A fast-switching LCD panel (placed in front of the CRT) acts as a color shutter, rapidly switching between red, green, and blue filters in sync with the CRT’s electron beam.
- Field-Sequential Color (FSC) – The LCD cycles through R, G, and B filters at a high refresh rate (e.g., 180Hz for 60Hz per color), creating the illusion of a full-color image.
Why LCCS Was Used
- High Resolution – Since the CRT provides the luminance, the display retains the sharpness of a CRT.
- Vibrant Colors – The LCD’s color filters allow for rich, accurate colors.
- No Convergence Issues – Unlike traditional RGB CRTs, LCCS avoids convergence problems (misalignment of electron guns).
DIY LCCS Display?
Building a true LCCS display from scratch is extremely difficult because:
- CRTs are obsolete – Finding a suitable monochrome CRT is hard.
- Fast LCD Shutters are rare – The LCD must switch colors at 180Hz+, which is not common in consumer displays.
- Precision Timing Required – The CRT and LCD must be perfectly synchronized.
Possible DIY Alternatives
If you want to experiment with field-sequential color (the core idea behind LCCS), here are some approaches:
1. Using a Monochrome CRT + External LCD Shutter
- Find a monochrome CRT (e.g., from an old oscilloscope or security monitor).
- Use a fast LCD panel (like a ferroelectric LCD or DLP-based color wheel) as a shutter.
- Synchronize the two using an FPGA or microcontroller (e.g., Arduino, Raspberry Pi, or a dedicated timing board).
2. Modern Field-Sequential Color Displays
- Some DLP projectors use a color wheel (similar to LCCS).
- OLED + Color Filter experiments (though not the same as LCCS).
3. Emulating LCCS with Software
- If you just want the look of LCCS, you could:
- Use a high-refresh-rate monitor (e.g., 240Hz).
- Write a program to cycle between R, G, and B frames (simulating field-sequential color).
Challenges
- CRT Availability – Hard to find suitable CRTs.
- LCD Speed – Most LCDs are too slow for true FSC.
- Synchronization – Requires precise timing between CRT and LCD.
Conclusion
A true DIY LCCS display is nearly impossible today due to the rarity of components. However, you could experiment with field-sequential color using modern displays or emulate the effect in software.
Would you like help with a specific part of this (e.g., finding a CRT, programming an FPGA for synchronization, or testing LCD shutters)? Let me know how deep you want to go!
- User
What if I have a black and white crt monitor already that can reach up to 1280x1024 resolution in 60hz?
- Assistant
Great! If you already have a high-resolution monochrome CRT monitor (like a 1280×1024 @ 60Hz model), you’re halfway there. The next challenge is adding a fast-switching color filter (LCD shutter) to turn it into an LCCS-like display.
Here’s how you could approach this:
1. Understanding the Requirements
For field-sequential color (FSC) to work smoothly:
- Your CRT must run at 3× the refresh rate (e.g., 180Hz for 60Hz per color).
- The LCD shutter must switch between R, G, and B at 180Hz (or faster).
- The CRT and LCD must be perfectly synchronized (no flicker or color ghosting).
Since your CRT only does 60Hz, you have two options:
- Option 1: Run the CRT at 60Hz and accept lower color fidelity (20Hz per color, which may flicker).
- Option 2: Overclock the CRT to 180Hz (if possible, but risky for older monitors).
2. Finding a Fast LCD Shutter
The LCD must switch colors at 180Hz+, which is rare. Possible solutions:
A. Use a Ferroelectric LCD (FLC)
- Faster than standard LCDs (microsecond response times).
- Used in some industrial shutters (e.g., 3D glasses, optical modulators).
- Hard to find, but you might salvage one from:
- Old 3D shutter glasses (e.g., NVIDIA 3D Vision).
- DLP projector color wheels (if you can extract the filter).
B. Use a DLP Color Wheel
- Some DLP projectors use a spinning RGB color wheel (similar to LCCS).
- You could extract the wheel and place it in front of your CRT.
- Downside: Mechanical spinning may not sync perfectly with the CRT.
C. Use a Modern LCD with Fast Response Time
- Some gaming monitors (e.g., 240Hz+ TN panels) might work.
- Problem: Most LCDs are still too slow for true FSC.
3. Synchronizing the CRT and LCD
You need a controller to:
- Drive the CRT at 180Hz (if possible).
- Switch the LCD between R, G, and B in sync with the CRT’s refresh.
Possible Controllers:
- FPGA (e.g., Xilinx, Altera) – Best for precise timing.
- Arduino + Fast Logic ICs – Possible but harder.
- Modified VGA/HDMI signal generator – If you can hack a high-refresh-rate source.
Example Workflow:
- Generate a 180Hz signal (e.g., from a PC with a custom resolution).
- Use an FPGA to split the signal into R, G, and B frames.
- Drive the LCD shutter in sync with the CRT.
4. Testing & Troubleshooting
- Flicker: If the LCD is too slow, colors will blend.
- Ghosting: If sync is off, colors will misalign.
- Brightness Loss: The LCD filter will reduce light output.
5. Alternative: Software Emulation (No Hardware Mods)
If hardware is too difficult, you could:
- Use a PC to simulate FSC (e.g., cycle R, G, B frames at 180Hz).
- View on a high-refresh monitor (e.g., 240Hz gaming display).
- Not true LCCS, but gives a similar effect.
Final Thoughts
- Best Case: If you can overclock your CRT to 180Hz and find a fast LCD shutter, this could work.
- Worst Case: You might end up with a flickery, low-color-accuracy display.
- Easier Alternative: If you just want the LCCS look, consider modifying a DLP projector (which already uses a color wheel).
Would you like help with:
- Finding a suitable LCD shutter?
- Designing an FPGA sync circuit?
- Testing CRT overclocking?
- User
Instead of using microcontrollers or fpgas, can't I just do it in software?
- Assistant
Yes! You can emulate LCCS in software without hardware modifications, but with some limitations. Here’s how:
1. Software-Based Field-Sequential Color (FSC) Emulation
Since LCCS relies on rapidly switching between R, G, and B frames, you can simulate this effect by:
- Generating R, G, and B frames in sequence at a high refresh rate.
- Displaying them on a high-refresh-rate monitor (e.g., 240Hz+).
How It Works:
- For 60Hz color output, you need 180Hz refresh rate (60Hz × 3 colors).
- If your monitor only does 60Hz, you’ll get 20Hz per color (flickery).
- If your monitor does 120Hz+, you can get smoother results.
2. Implementation Steps
A. Using a PC with a High-Refresh Monitor
- Set your monitor to the highest refresh rate possible (e.g., 120Hz, 144Hz, 240Hz).
- Write a program (Python, C++, or even a shader) that:
- Renders three separate frames (R, G, B).
- Cycles through them in sequence at the monitor’s max refresh rate.
- Use a color filter (optional):
- If you want a true LCCS effect, place a physical RGB filter (e.g., a spinning color wheel) in front of the screen.
- Without a filter, the colors will blend in software (less accurate).
B. Example Code (Python with Pygame)
import pygame import numpy as np # Initialize screen (adjust resolution & refresh rate) pygame.init() screen = pygame.display.set_mode((1280, 1024), pygame.DOUBLEBUF) clock = pygame.time.Clock() # Create R, G, B frames (example: grayscale image tinted per color) def generate_frames(image_path): img = pygame.image.load(image_path).convert() r_frame = img.copy() g_frame = img.copy() b_frame = img.copy() # Tint each frame (simplified) r_frame.fill((255, 0, 0), special_flags=pygame.BLEND_MULT) g_frame.fill((0, 255, 0), special_flags=pygame.BLEND_MULT) b_frame.fill((0, 0, 255), special_flags=pygame.BLEND_MULT) return [r_frame, g_frame, b_frame] frames = generate_frames("test_image.png") current_frame = 0 # Main loop (cycle through R, G, B at max speed) running = True while running: for event in pygame.event.get(): if event.type == pygame.QUIT: running = False screen.blit(frames[current_frame], (0, 0)) pygame.display.flip() current_frame = (current_frame + 1) % 3 # Cycle R → G → B clock.tick(180) # Target 180Hz (if monitor supports it) pygame.quit()(Note: This is a simplified example. For best results, use a low-latency game engine or GPU shader.)
3. Limitations of Software-Only Approach
- No Physical Color Filter → Colors blend in software (not true LCCS).
- Flicker at Low Refresh Rates (e.g., 60Hz monitor = 20Hz per color).
- Requires High-Refresh Monitor (120Hz+ for decent results).
4. Hybrid Approach (Software + Simple Hardware)
If you want closer to real LCCS, you could:
- Use a high-refresh monitor (e.g., 240Hz).
- Add a passive RGB filter (e.g., a spinning color wheel from a DLP projector).
- Sync the wheel speed with the software (e.g., using a motor controller).
5. Best Case vs. Reality
Method Pros Cons Pure Software No hardware needed Colors blend, flicker at low Hz Software + Filter Closer to LCCS Needs mechanical sync FPGA/CRT Mod Most accurate Complex, requires rare parts
Final Verdict
- If you just want the "look" of LCCS, software emulation works.
- If you want true LCCS, you’ll need hardware sync (FPGA or motorized filter).
Would you like help optimizing the software for minimal flicker or finding a physical color wheel?
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.