Skip to content
The Chat Archive
mistral-medium-2505· Mistral AI LMArena Human Preference 140K

I am talking about LCCS, which is a technology thwt JVC employs in some small…

  1. 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

  2. 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

    1. CRT as the Light Source – A monochrome (black-and-white) CRT emits a bright, high-resolution image.
    2. 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.
    3. 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!

  3. User

    What if I have a black and white crt monitor already that can reach up to 1280x1024 resolution in 60hz?

  4. 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:

    1. Generate a 180Hz signal (e.g., from a PC with a custom resolution).
    2. Use an FPGA to split the signal into R, G, and B frames.
    3. 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?
  5. User

    Instead of using microcontrollers or fpgas, can't I just do it in software?

  6. 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

    1. Set your monitor to the highest refresh rate possible (e.g., 120Hz, 144Hz, 240Hz).
    2. 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.
    3. 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:

    1. Use a high-refresh monitor (e.g., 240Hz).
    2. Add a passive RGB filter (e.g., a spinning color wheel from a DLP projector).
    3. Sync the wheel speed with the software (e.g., using a motor controller).

    5. Best Case vs. Reality

    MethodProsCons
    Pure SoftwareNo hardware neededColors blend, flicker at low Hz
    Software + FilterCloser to LCCSNeeds mechanical sync
    FPGA/CRT ModMost accurateComplex, 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?

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.