Fun with the Sega Genesis - Ultimate Portable Game player

Found a crazy deal on fleabay for one of these and had to have it. I had heard stories of how badly they are made, and how miserable the audio is.
All very true, but I think it can be improved a little.

The video is great, the size a too small, the sound from the speaker is crap but the sound from the headphone could be worse.
I immediately took it apart after opening the box. I was THRILLED to see only one epoxy-chip and several SOP's! :D

I want to believe that the audio issue is because of the amp/filter they have used. Through headphones, it sounds ok, but also a little clipped and shallow. This could also be because of the power supply, which is very weak. The battery is 3.7v and droops when the PSG is loud.




Its like a portable MP3 player considering all the titles that have sound tests. :p
You know, except horrible sounding.

Do not stay at the Guest Quarters Hotels - Dumping The Miracle Piano Teaching System

I had my Willem programmer pulled out for some Sega Genesis programming stuff and decided to finally dump the eprom inside of the Miracle Piano teaching System Keyboard. If you recall from a previous post of mine, it contained a 27c256 OTP eprom. It also contained many proprietary ICs of which I may never figure out. We may never know what microcontroller they used or what language the machine code is suppose to be written in. z80, 6502, etc.

In any case; with many vintage computers and other devices containing ROM, the authors always find the space to sign and date their work and in rare cases they may even decide to add a little easter egg. Although I cannot locate a date, here is some clear text I found in the ROM image:

"This Eprom contains code created by Mike Collins. Anne Graham and Ray Livingston. Do not stay at the Guest Quarters Hotels. Keep that Coke classic and that Piping hot coffee coming."



I got a real kick out of reading that. For anyone who knows what to do with it, here is the binary file:
http://www.mediafire.com/download/eo3zujca7jvw44f/MPTS_ROM.zip

Intec PS2 LCD screen Mod

I found a controller at a junk shop for $5, and figured I would mod it onto a console. For the longest time I couldn't figure out how to add it to a console because I didn't know which cable was which. Now I figured it out: Orange: +12v (connects to a 7808 regulator so the voltage range should be greater and lesser than 12.) Black: Ground Brown: Ground Red: Right Audio input White: Left Audio input yellow: Composite video input Now I can finally build it into something. Maybe my new Sega Genesis 3, since it will fit right on the face of it and hopefully can share the same +10v power supply!

Arduino - Cast Int to Byte - What happens?

For a project I need to spread a 16-bit unsigned integer across one byte variable and two 1-bit variables, all of which will be written to pins. The reason is not important, but I needed to know what happens to the byte value when I cast it to the byte variable. I understand that it will be truncated, but what will? The higher 8-bits or the lower 8-bits?

To find out, I wrote a quick program with a lot of clear text output.

// cast test by Jordan
// Test truncation of variables from one type to another
// most importatntly: int to byte

unsigned int intVar = 0x4080; // will it truncate to 01000000 or 10000000?
byte byteVar = 0x33;
void setup(){
  Serial.begin(9600);
  Serial.print("hello world.");
  Serial.println();
  Serial.println();

}

void loop(){
  Serial.println("integer variable equals: ");
  Serial.println(intVar, BIN); // print variable in binary
  Serial.println();
  Serial.println("byte variable equals: ");
  Serial.println(byteVar, BIN);
  Serial.println(".");
  Serial.println("..");
  Serial.println("...");
  byteVar = (byte)intVar;
  Serial.println("byte variable now equals: ");
  Serial.println(byteVar, BIN);
  while(1){} // loop forever
}

Then I uploaded it to my Arduino Nano and opened the serial monitor. I then uploaded it to my Teensy 2.0 to double check the code across platforms. Teensy is a little different in some aspects, so I had to make sure. They both output exactly the same thing:

Serial monitor output:

"hello world.
integer variable equals:
100000010000000
byte variable equals:
110011
.
..
...
byte variable now equals:
10000000"

These are the exact results that I wanted to see. I may continue on with more programming now...

EDIT: Further testing proves that the same theory does NOT hold true with booleans. (get it? "true") I had hoped that the boolean could be used to store a 1-bit number, but it turns out they are actually some sort of integer in disguise! I will have to figure out some fast way to manipulate individual bits...

Repairing an LCD Monitor

I am damn cheap, and this isn't the first time I have gotten a broken monitor to use as my own. By broken, I do not mean that the LCD is cracked, but that it comes on and goes off immediately. Some even went black and had a buzzing noise. More often than not, this means some capacitors on the power board are swollen or popped. This is just a detailing of one monitor in particular, but the method is nearly identical to other modern screens. The other problem that could occur seems less common, so I will not cover it here. The less common problem is the wires connecting to the CCLF tubes coming loose.

Step 1. Open the screen.
Unplug the monitor and press the power button a few times to (mostly) discharge any good capacitors.
Find all of the screws that are visible including VGA/DVI mounting screws and remove them, keeping a good idea of which holes they came from.

Now pry apart the plastic shell carefully. I use an expansion slot cover found on the back of a PC because they are wider than a screwdriver and leave less cosmetic damage (if any at all). Once you have the plastic bevel popped all around the edges, place the screen on your surface area, or lap, face down and lift the plastic off the back. This may not be the exact way for all monitors, but it has been for the last four I repaired.

Step 2. Take note of the orientation of the wires leading from the metal shielding. THese connecto to the high voltage CCFL tubes and may or may not be polarized. Don't screw this up! Take a photo if it helps.



Remove the metal shielding from the power and logic boards. Be very careful of any ribbon cables.
You should find the power board which is suspect.



Step 3. Inspect the power board. If you find swollen capacitors, you probably found the culprit. In our case, there are two swollen capacitors. From my experience, they normally go out in pairs, but I cannot prove that. Can you see the two fatties?




Step 4. Replace the capacitors with a "good" brand. Nichicon is my favorite. Make sure that the Farads are matched exactly and that the voltage is either the same or higher. Higher is better in this case, but normally the caps become larger with a higher voltage tolerance.



Step 5. Put it back together and power it up. ta-da! Although this is not 100% to work for you, it is a common problem and an easy fix. Good luck and good modding.

-Jordan

 ps. The monitor in this example was the Westinghouse L1975NW. I replaced two 220uF 25v capacitors with two 220uF 35v capacitors.
I also repaired an Acer x193w+ with new caps and some other Acer I no longer have.
One time I found that a Dell E2K-SE198WFPF(B) by reconnecting the CCFL tube with its wire which was difficult and apparently dangerous. To do so I had to disassemble the screen itself, LCD, polarizing film, and other layers just to get at the tubes...which were well encased in rubber. It was very difficult and I don't think that I would attempt it again.

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. 

Update: Sega GameGear CPLD Cartridge(s)

Just an update for an old post I made.

http://jazz-disassemblies.blogspot.com/2013/09/gamegear-cpld-cartridge.html

Remember the Flash cart that Majesco made with a CPLD as the mapper? Well, I tried again to get a pirated ROM to run in place of the old Caesar's Palace ROM and it refuses to!

Dumping the Binary for Caesar's Palace, it is an exact hex match with the copy circulating on the internet, so I know whatever mapper is contained on the CPLD must at least support ROMs up to 256 KBytes, because Caesar's Palace is that large. I tried the Fan translation of Phantasy Star Adventure which is only 128 KBytes and it will not run. I even duplicated it across the full capacity of the flash ROm just in case one of the higher address bits was tied to something I didn't see, like A18 on a 49F040 being tied to VCC. It still refused to run...

Doing some research on the GG and different BIOS versions, some GameGears check 0x7FF0 for a line of text, which is in fact present at the location it needs to be. I have tried everything and yet it still refuses to boot up. I am rather upset by all of this, which is why I am going to make my own flash cart for the GG! BLARG!

VileTim and others have made CPLD versions of the original 315-5912 Mapper chip included in a few Sega Master System and Sega GameGear carts. Obviously the goal is to design a board that makes it so we can use commercial and modern components rather than salvaging and destroying official devices. The first point I am trying to make is to design a board that supports 512 KByte ROMs, homebrew or otherwise. Then I would like to add SRAM and a battery because I am hopeful for a music tracker that runs on SMS and GG in the future.

LSDj is getting old in my opinion and there are other devices that make unique and varied sounds, such as the 76SN489 inside of the GG and SMS.

Anyhow, I have now completed a version with an official mapper that 'should' support up to 512 Kbytes when using a 49F040 ROM.



I am also working on two simultaneous versions that include SRAM and a battery, but they are going much slower because I am running out of room for traces...






The board containing a 49F040 still holds up to 512KBytes, but the TSOP can only hold up to 128KBytes. This downgrade is because the TSOP is much more available than the 49F040 and much easier to route traces to.

The two latter boards are also a little taller than the other board. The first one I designed was based on an actual official game, garfield or something, which does not fill the entire shell. The other boards I measured just how much more I could fit inside of the shell and still have it close without any cutting, which is important to me.

The second biggest concern of my boards is that I hope to get them to support Sega Master System Homebrew and ROMs. The jumper between cart pins 41 and 42 is an SMS/GG selector. when it is bridged, the GG runs in GG mode, but when it is cut, it runs in SMS mode. I have done no (successful) testing of this just yet, but I will surely post about it once I do.

Stay tuned