Now that we understand how NTSC color coding works and the math behind 
it, its time to think of ways to implement color coding. Knowing the 
math helps because that knowledge equips us to abuse the system and code
 color using simpler/cheaper hardware.
Recapitulating, the NTSC video signal consists of two
 components, the luma signal which tells the TV the brightness of a 
"pixel" and chroma signal which tells the color of the "pixel". The luma
 signal is simple enough. Higher voltage levels represent brighter spots
 while lower levels represent darker spots. The chroma is a tad more 
complicated. Color information is QAM modulated onto a subcarrier wave.
Some of techniques used to generate NTSC color are
1. Doing the QAM modulation in analog hardware. With all the recommended
 filters, this easily produces the best results. Whats more, the input 
can be in the form of RGB which is a big advantage over doing something 
in some unknown color space. The AD725 does this. The drawback is that 
its rather expensive and takes out most of the fun from NTSC color 
generation. Hobby projects are most often fun because of the DIY nature 
of the project. Having an ASIC do the job is a downer for me.
2. Putting out square waves instead of sine waves and controlling the 
phase of the wave. Achieves really good results. Most suitable on an 
FPGA where a phase accumulator can be easily designed. Implementing PAL 
is also quite easily possible. See [2]
3. A variant of #2 that uses discrete hardware. A series of NOT gates or
 buffers can be used to create phase delays. Various points on the delay
 chain are tapped and fed to a multiplexer. The microcontroller selects 
which phase to be output at that point of time so that the "pixel" has 
the color its supposed to. Needs a LOT of hardware and wires. You are 
left at the mercy are delay variations over temperature , manufacturer 
and batch of the chip. See [3] , [4] and [5].
4. A variant of #2 that uses SPI to create phase delays. This easily 
requires the least hardware. At high enough SPI Clock, a wide range of 
colors can be obtained. At 28.636Mhz ( 8 x Fsc ), 8 phases can be 
created. This allows for 8 "pure" hues and a number of mixtures, many of
 which are identical. This technique is great but there is a slight 
catch. If implemented as per NTSC spec, each line is 227.5 cycles long. 
So the phase of the color burst inverts if you take the sync tip as 
reference for each line. Implementing this inversion happens 
automatically with other techniques. But with SPI, this has to be done 
manually. When using this technique, this inversion is ignored and the 
length of each line is rounded to either 227 or 228 cycles. But this 
results in poor color transitions with distinctly visible bands at transitions. See [6] , [7].
Here's one technique I came up with that no one has used so far.
5. A digital variant of #1. The idea is create different phases of the 
color carrier ( either by a delay chain or ring counter ) and instead of
 multiplexing the outputs, we add the phases in a manner that can be 
controlled digitally. I've been able to get this to work on LPC1768 and 
Atmega16. I'll publish the results soon. It requires minimal extra 
hardware and enables even the slowest 8-bitters to generate NTSC color 
video.
It may look a little too much to implement with discrete circuits, but with a few tricks, a very simple circuit is possible.
References
1. AD725 Datasheet
2. PAL using FPGA
3. XGS AVR
4. Lazarus-64
5. Atmega64 GameStation
6. RBox
7. Apple II graphics

 
 
That's an odd way of showing example 5, look at how the NES did it's color phases. It used a ring counter as you said, and the input into the 0th register is the inverted output of the last register. This gives both the negative and positive versions of the outputs which are then input into a n:1 mux to select the output, where n is the amount of color divisions. (Actually it's a little more complicated in the actual hardware, via the patent, but it's cool!)
ReplyDeleteSo if you were to take the clkout of the LPC1768 to clock them, you'd have full color in about 3-4 74xxx IC's
ReplyDelete+--------------o<|-------------+
+-[R]->[R]->[R]->[R]->[R]->[R]-+ 0V 5V
| | | | | | | |
---------------------------------------
[ 0 1 2 3 4 5 6 7] <- hue[2:0]
---------------------------------------
| o
| |
---------
[0 1]<-- hue[3]
---------
|
digital color phase signal
piss poor drawing, sorry!
Oops, it didn't draw correctly. Basically you have an inverter up top taking the last registers output as the inverter's input, and outputting it into the first register's input.
ReplyDeleteYou take the outputs of each register and put them into a mux, selecting which one of these represents your hue. You can either input both the outputs and their compliments, or you can just two smaller multiplexers to output the final digital chroma signal
Oh, and of course, the each register, rn's output goes into the input of the rn+1. Lastly, you clock these registers at n times the frequency of NTSC (or PAL). So if you want 12 different hues, you have 6 registers and clock the registers at 6xNTSC. If you want 16 different hues, you have 8 registers and clock them at 8xNTSC.. etc etc..
ReplyDeleteNo more posts until a reply, I promise! SORRY! If you want to condense this all to one post, please do!
Thank you for the insight on the NES system.
ReplyDeleteThe idea in method 5 is to do all of the things in the figure with only passive components. I havent had time to put up the circuit.