Composite Video from the Nintendo Gameboy

My latest project is to get some sort of video output from the nintendo gameboy. The signals are all present, but are not in a form that can be connected to any television or monitor. My first thought is to convert the signals into a single analog signal called composite video.

Composite video is named as such because it contains color data (chroma), brightness (luma) and synchronization on wire.

1. Chroma is not important in this case becuase the gameboy is monochrome. All of the color differences will be made with Luma.

2. Luma: As above, the Luma will be used to create our four different colors. The TV looks for an analog signal here. The gameboy has two data pins which are used for this purpose, so connected through a DAC of some sort, we can create four different levels rather than just 0v and 5v.

3. Sync
 Csync or composite sync is an XOR of horizontal and vertical sync. These two signals tell the television to move down one line or to move back to the top of the screen. I am not quite sure how progressive or interlaced are determined by these just yet.

Next, these have to be connected together over one wire. As mentioned, the luma is an analog value but what I forgot to mention was that it is a positive signal whereas sync is negative. From what I have read, composite must be AC coupled because the TV input is DC coupled. That being said, our sync can actually be positive as well, as long as the luma is offset by DC value. Once the signal goes into the TV, the DC coupling circuit will block the average DC offset which is our black level. Black level will become 0 volts inside the Tv so sync will become 0v to -0.4v and Luma will be between 0v and +0.7v.

I am not at liberty to share my schematic at this point but it doesn't' work that well anyhow. :P
As a first attempt however, the result is quite promising.

You will notice that the image scrolls in several directions and that it is repeated three times over from left to right. I believe this is a problem with synchronization and possibly the LCD itself.

Updates to follow shortly. 

Miracle Piano Final Thougts

I finally had time to probe a few pins inside the Miracle Piano.

AS0012 - Pin 21 (PWM)
It turns out this pin controls the master volume and NOT the envelope as I had originally assumed.
Turning on the keyboard, this pin defaults to about 50%, but as you can see, it is not exactly 50%. How odd.
When the volume is reduced, the pulse width is widened and when the volume is increased, the pulse width is reduced. That is because the integrator, U4A is inverting the output.

Each photo has the scope set to 10 microseconds per division:

Default Volume:



Highest Volume:



Lowest volume:



U4 - Pin 1
This pin goes to the LM13700 to control the master volume, or gain of the sound. It appears as a DC voltage and is remarkably solid. There is no visible ripple as would be expected from an integrator.
No photo is needed of this signal.

J004 - Pins 21-24 (OUT1-OUT4)
The signals from these pins are too small to view on my scope, so I chose the amplified versions from U10. Pins 1, 8, 7 and 14 respectively.

OUT1 is not active for all sound samples, apparently. When Harpsichord and Synthesizer are selected, nothing comes out at all.
When the other four sounds are selected however, the waveform is perfectly clear.

OUT2 is the opposite. Only when Harpsichord and Synth are selected, do we see any activity on this pin.

OUT3 mimics OUT1 exactly, or at least as far as I can tell.

OUT4 on the other hand does not seem to react to any button or key. It simply outputs a DC voltage which measures 5.03v at pin 14 of U10.

I can speculate as to why there are three OUT pins. While probing both Pins 8 and 14 of U4 which has the mixed and filtered outputs split to both left and right output terminals, the waveforms are identical for Harpsichord and Synthesizer but are not identical for the other four sounds. It would seem that Harpsichord and Synthesizer were recorded and digitized in mono while the other four sounds were recorded and digitized in stereo.

I am a little saddened that the envelope is not broken out to any specific pin or sub-circuit.

Some other Notes

J004 - Pin 40 (Bus Strobe)
This pin reacts differently for different sounds, however, when the key is pressed with a sound that has an attack and release; the pin will strobe for the full length of the sound and go to 0 when the note is finished.
For a sound that ends only when the key is released, the pin strobes at key press for a moment, then goes to 0 and strobes once again when the note is released.

I could use this pin for creating a gate and trigger, but it would require that I charge a capacitor then feed it through a comparator and set up some logic to keep the signal high when the key is pressed and low when the key is released. This wouldn't require too much effort, but the function would change from sample to sample since the envelopes are all different. I don't thin the modification is worth it in this case.

"Piano" sample is very hard to photograph since the amplitude changes so rapidly in software. It looks very similar to "Organ, but is more rounded whereas the Organ is more triangular.


"Organ:"



This photo shows a sample that is identical on both sound channels. Trust me, they are identical but the channels are not being displayed the same way.


These two photos show sounds that are not identical from OUT1 and OUT2.



PS: Yes, the reflection in my oscope is naked. Deal with it.

Adding Analog Pins to Arduino pt.2

Don't forget part 1: http://jazz-disassemblies.blogspot.com/2014/01/adding-analog-pins-to-arduino-pt1.html

The first step in part 2 of adding analog pins to an arduino is by getting rid of the MCP3008! Yes, I am sorry but that particular IC is overly complicated and too expensive for what it offers.

Since I wrote that first part, I began looking for alternatives because of the price of the MCP3008. Even in quantities of 10 or more, the IC was still more expensive than a bare Atmel microcontroller! At first I thought that I could buy another microcontroller for less than the MCP3008 at a fraction of the cost and even be able to simplify the methods of communication to my own liking.

After looking for the cheapest, yet adequately powerful uC, I came across the ATtiny48 which has several Analog inputs and even more digital IO's. The Analog inputs would in theory, be read, stored in variables and then transferred to the master microcontroller across an 8-bit wide data bus. The particular analog value that would be transferred would be selected by the master uC via three other pins; select bits. The pins were going to offer a binary value which would select the current pot to be transferred.

This method would allow for me to read many many more pots than the master microcontroller was equipped with, but at a large cost; the cost of many digital IO pins. One way to get those digital IOs back would be to use analogWrite on one of the PWM outputs and connect that pin to an analog input on the master uC. Considering that, I could sacrifice one analog input for 8 more. HOWEVER, the AT48 has no PWM outsputs. :(

After mulling over it for a long time, I realized what I had actually designed. The program I had spent an hour writing... The program that utilized the exact methods of communication to suite my exact needs...was, you guessed it: An analog multiplexer which decodes 3-to-8 inputs. They have an app...I mean IC for that. The 74HC4052 accepts two sets of 4 analog inputs and connects them to one of two outputs respectively. Two select bits, choose the analog input to transfer to the output.

The 4052 is a mere 50 cents, requires no external programming, runs on a large voltage range and comes in a variety of packages!

I will simply import photos and descriptions of my project, so that I can describe how to use the 4052.
Analog pins A0-A3 are used for higher priority data, so that leaves A4-A7 open. Again, we will also need two digital IO to use as select bits on the 4052.

// ***************************************************************
// define pin connections
// ***************************************************************

int pSelect0 = 3;
int pSelect1 = 4;

// ***************************************************************
// define variables
// ***************************************************************

// locate the delay between the select bits and the updated output
// of your 4052 IC and update this value:
int latency = 100; 

byte aVal00 = 0; // analog Value, 4052 # 0, input 0
byte aVal01 = 0; // analog Value, 4052 # 0, input 1
byte aVal10 = 0; // analog Value, 4052 # 1, input 0
byte aVal11 = 0; // analog Value, 4052 # 1, input 1

byte aVal02 = 0; // analog Value, 4052 # 0, input 2
byte aVal03 = 0; // analog Value, 4052 # 0, input 3
byte aVal12 = 0; // analog Value, 4052 # 1, input 2
byte aVal13 = 0; // analog Value, 4052 # 1, input 3

byte aVal04 = 0; // analog Value, 4052 # 0, input 4
byte aVal05 = 0; // analog Value, 4052 # 0, input 5
byte aVal14 = 0; // analog Value, 4052 # 1, input 4
byte aVal15 = 0; // analog Value, 4052 # 1, input 5

byte aVal06 = 0; // analog Value, 4052 # 0, input 6
byte aVal07 = 0; // analog Value, 4052 # 0, input 7
byte aVal16 = 0; // analog Value, 4052 # 1, input 6
byte aVal17 = 0; // analog Value, 4052 # 1, input 7

// ***************************************************************

// Setup

// ***************************************************************

void setup()

{

Serial.begin(9600);

// define pin modes   

pinMode(pSelect0, OUTPUT);

pinMode(pSelect1, OUTPUT);

}  

// ***************************************************************

// Main Loop

// ***************************************************************

void loop()

{

getAnalog();

processAnalog();

}

// ***************************************************************

// Get Analog Values

// ***************************************************************

void getAnalog()

{

  // read the first set of four

  // part 1 of 4

  digitalWrite(pSelect0, LOW), digitalWrite(pSelect1, LOW); // 00

    delayMicroseconds(latency);

  

aVal00 = map(analogRead(A4), 0, 1023, 0, 255),

aVal01 = map(analogRead(A5), 0, 1023, 0, 255),

aVal10 = map(analogRead(A6), 0, 1023, 0, 255),

aVal11 = map(analogRead(A7), 0, 1023, 0, 255);

  

  // read the second set of four

  // part 2 of 4

  digitalWrite(pSelect0, LOW), digitalWrite(pSelect1, HIGH); // 01

    delayMicroseconds(latency);

  

aVal02 = map(analogRead(A4), 0, 1023, 0, 255),

aVal03 = map(analogRead(A5), 0, 1023, 0, 255),

aVal12 = map(analogRead(A6), 0, 1023, 0, 255),

aVal13 = map(analogRead(A7), 0, 1023, 0, 255);

  

  // read the third set of four

  // part 3 of 4

  digitalWrite(pSelect0, HIGH), digitalWrite(pSelect1, LOW); // 10

    delayMicroseconds(latency);

  

aVal04 = map(analogRead(A4), 0, 1023, 0, 255),

aVal05 = map(analogRead(A5), 0, 1023, 0, 255),

aVal14 = map(analogRead(A6), 0, 1023, 0, 255),

aVal15 = map(analogRead(A7), 0, 1023, 0, 255);

  

  // read the last set of four

  // part 4 of 4

  digitalWrite(pSelect0, HIGH), digitalWrite(pSelect1, HIGH); // 11

    delayMicroseconds(latency);

  

aVal06 = map(analogRead(A4), 0, 1023, 0, 255),

aVal07 = map(analogRead(A5), 0, 1023, 0, 255),

aVal16 = map(analogRead(A6), 0, 1023, 0, 255),

aVal17 = map(analogRead(A7), 0, 1023, 0, 255);  

  

  

  return; // return to main loop    

return;

}

// ***************************************************************

// Process the values

// ***************************************************************

void processAnalog()

{

// Do whatever you would like to do with the values here

return;

}

// ***************************************************************

That is all. I realize that the getAnalog function could be simplified using an array, but I did it quickly. If anyone wants to make that change, please share it! Also, I used the map function to change the analog value that was read from 10-bits to 8-bits. I have my reasons, but anyone may remove that if they want a higher resolution. 

There you have it. 16 independent analog values on top of the 4 I needed for something else. With all of the analog pins at our disposal, you could have 32 analog values! I am using this for 16 pots and the other 4 for external control voltages. Just imagine, 32 analog values with a simple Atmega168. 

Keep up with future posts to see when I actually breadboard this out.