Archive for February, 2019

RGB modding a JVC TM-A140PN

Thursday, February 28th, 2019

In case you’re looking for TM-H140PN look here:

Note: This guide works for TM-A140PN, TM-A14PN, TM-A13SU and TM-A130SU.

So, a friend of mine got a hold of some JVC TM-A140PNs (and TM-A14PN which is the same, but in plastic casing) which only takes composite and S-Video. So since nobody likes that, we wanted to RGB mod it. Open the sucker up, desolder the large metal shield in the middle of the board, and behold, a TB1226EN jungle IC. Since I now had some experience with the newer TA1276AN, I was somewhat prepared that shit might hit the fan. And of course, it did.

TB1226EN and where the capacitors were, and the I2C lines. All components mentioned can be seen here.

So blanking occurs with pin 22, Analog YS, and since I chose to blank on 5V (from SCART), we need proper pull-down, in order to avoid excessive current drain. So I switched the something like 10 Ohm resistor that pin 22 was grounded with (R726), to a 10K, so when 5V is applied, current draw is minimal, and when not, we still have 0V to allow composite/S-Video as before. After doing this, we could see that we could blank by attaching 5V to the pin and see the screen turns black. After removing C718, C717 and C716 which were the capacitors decoupling RGB pins to ground (as there is a DC offset voltage on these pins, just like the TA1276AN) and then injecting RGB to pin 23 (R), 24 (G) and 25 (B) through the same circuit as with the TA1276AN, we still got black screen when applying video.

The per line input circuit

So, with previous experience in mind (check the DT-V100CG RGB modding post), I hooked up the Arduino circuit to the I2C lines, by removing R292 and R291 and using that as entry point. R292 is the SDA line (yellow cable in the pictures), and R291 is SCL (green cable). On each line there’s also 100 Ohm resistors in-line (as in series), both on the incoming I2C and on the “new” I2C bus (they’re the resistors inside the black shrink tube). The side closest to the jungle IC was connected to the “new” I2C bus created with the SoftI2CMaster library, and the other to the hardware I2C/TWI. Firing up the screen, it didn’t boot at all. I could see it was communicating, but it never initialized properly. It seems that it is really sensitive to timing, and at the same time, the monitor software is *constantly* refreshing *every* single goddamn register in the jungle IC. So I had to rearrange the code which was somewhat trial and error, until I had something that could start.

Anyway, after doing that, I could see that the monitor software wrote 0h to register 06h, which is the RGB contrast register. Yay! Thanks for killing the RGB image! Anyway, some I2C packet mangling, and were good again. Basically, when the monitor writes to register 06h we ignore it, and when it writes to 00h we replicate that to 06h.

Glorious Mega Man X

At the same time, I ensured that it would never mute RGB in register 1Bh, if for some reason it would think of doing that. Contrast setting on the OSD will now also work, as data is replicated to RGB contrast register. Sync was attached to line B at the board on the pin, so it is properly routed to the sync and Y pins of the jungle. Audio from SCART was merged to mono, by the below circuit and then soldered to the RCA input pin inside the monitor.

Merging stereo to mono at line level. I found it somewhere on the internet, can’t remember where….

I then 3D printed a small “case” to put SCART on the back of the monitor, with RCAs to send audio out, and then a switch to switch between the RCAs and sending audio to internal mono shitty speaker.

Find the code for the Arduino here:

RGB wiring and sync. The Arduino was moved later.
The input circuit (the in-line resistors are directly in the cable)
The Arduinos final place
Kirby Superstar
SCART input block

So there you have it!

RGB Modding a JVC DT-V100CG

Thursday, February 14th, 2019

TL;DR Some monitors don’t treat the registers regarding RGB picture of the TA1276AN jungle IC correct (as was the case with the JVC DT-V100CG), so when RGB modding these, the picture is dark or non-existent. I made some code for an Arduino that make it act as a bridge between the monitors MCU and the TA1276AN, for when RGB modding sets that use this jungle IC. Find code here:

Tell me more!

So I bought this small 10″ JVC monitor, that included the IF-C151HDG SDI card, and the manuals stating that an RGB card, the IF-C101CMG, should exist (no, not a IF-C01COMG, it’s not a typo). This card seems to be elusive, and I cannot find anyone who has actually seen one in real life, so I have doubts that it was ever released, also given how late in the CRT era this monitor was made.

The JVC DT-V100CG with a US Super Nintendo on top.

As I use my CRTs for retro gaming, I wanted analog RGB inputs, just like on my larger JVC sets, where I also cloned the IF-C01COMG card. Anyways, I started looking at the schematics (it’s on and how the IF-C151HDG worked, to get an idea of how the IF-C101CMG card might’ve been expected to work. It quickly became obvious that the DT-V100CG would never natively take RGB in, at least without modding the mainboard, as the RGB lines were unconnected (the schematics show them being coupled to GND through some capacitors, but they’re not mounted), and the pin that selects RGB on the jungle IC, YS2/pin 32, was directly tied to GND. The IF-C151HDG card converts the SDI signal to RGB, which is then “transcoded” to YPbPr through an analog circuit, which is then thrown into the jungle IC. Since the jungle IC converts back to RGB for the CRT, I started to feel this was a long way for an analog signal to run.

Anyways, the monitor uses the quite common (at least for JVC sets) Toshiba TA1276AN jungle IC, and many guides exist for RGB modding sets that use the same jungle, so I thought that that was the way to go. Looking at the schematics and PCB layouts, it seemed that I first needed to release the YS2 from GND to be able to control RGB. After severing the trace around the pad, I could measure that it was *still* connected to GND.

The severed pin 32

Looking closer at the PCB, I could now see that there were more than 2 layers of copper, but the other layers aren’t shown on the layout in the service manual, so the pin was most likely attached to GND also on a deeper layer. So the only thing left, was to lift the pin. So I did that, and attached the pin to a DPDT switch, that switched between 0V and 5V. According to the datasheet of the TA1276AN when YS2 is above 0.75V it switches to the RGB lines. You can find 5V on pin 15, at least on the DT-V100CG.

After attaching the switch, I tested that I could activate the RGB pins by connecting a composite video signal to one of the input ports, and then flip the switch to see the image become black (because I hadn’t attached RGB yet).

The lifted pin 32
Cable attached to pin 32 (I added some hot glue to ease strain later)
GND and 5V for the switch
RGB blanking switch

The RGB video signal should then be connected, which are pin 35/red, pin 34/green and pin 33/blue. Sync goes to Y1/pin 15, but instead of wiring to that pin, I simply wired to one of the composite inputs, as they also end up being routed to Y1.

Sync attached to composite input A

Now the RGB lines are shown to be 0.5 Vpp levels in the datasheet, which is a tad lower than the usual 0.7 Vpp. As it is desired to terminate the signals with 75 Ohm resistors to keep signal integrity, attenuating the signal to 0.5 Vpp requires a resistor around 30 Ohm in series with the signal. The 30 Ohm resistor is somewhat optional, since the jungle IC does accept the 0.7 Vpp signal, however this might cause a too bright image. I actually decided to put 15 Ohm in 😛

The circuit to attach to each RGB line (meaning 3x this)

So after making this, I attached a SCART plug, and fired everything up, aaaaaand black screen… Nothing was coming through. Now I had just heard a similar story from another user modding a JVC monitor with the same jungle IC, so I got curious. The other user had gotten a faint image, by removing all the resistors (the caps are necessary as the TA1276AN has a DC offset on the inputs) so I tried the same, and voila, there was a faint image, unusable, but still there. So the signal *was* coming through the chip, but it was *really* dark. OK, so I tried measuring it all through, to see if there was some short circuits or whatever to ground, I measured with an oscilloscope that the signal levels coming in were the right voltage, and so on and so on, but all was good.

I noticed that the brightness and other settings I could tamper with through the OSD, did absolutely nothing to the image. I then started to read the datasheet of the TA1276AN more thoroughly, to understand how this worked, and found out that all these settings, brightness and so on, are controlled by the monitors microcontroller (MCU) through an I2C line. I then saw that there were separate registers for brightness and contrast, depending on if it was external RGB (pin 33/34/35), or the internal signal generated by the chip itself from the composite video, S-Video or YPbPr. I then attached a logic analyzer to the I2C line and could see that brightness and so on wasn’t written to the RGB registers. But the two registers should be predefined to 80h, so unless the MCU actually reset them, they should still be good (except the most significant bit of the RGB contrast register, HI BRT, more on that later).

There is a lot of communication with different chips on the line, so I decided to sniff what was coming to this exact chip only, so I wrote a small program on an Arduino that acted as a I2C slave on the same address as the TA1276AN, that would write the data it received out to the serial debug. The I2C address of the TA1276AN is 44h, although stated as 88h in the datasheet, but this is because the datasheet specifies the address along with the I2C read/write bit, which is the least significant bit in the address byte. When writing, this bit is 0, so 44h shifted one bit left plus 0, is 88h. For the same reason they specify that the read address is 89h, because when reading, the least significant bit is 1, so 44h shifted one bit left is 88h plus 1, 89h. Anyways, since having two units with the same address on an I2C line is bad, because they’ll both acknowledge the data, I inserted a buffer between the Arduino and the I2C line (made by serial coupling two 74HCT04 inverting buffers per line), so the ack from my Arduino would go unnoticed. I could then read all data coming to the jungle IC, and noticed that register 05h (RGB brightness) and 06h (RGB contrast), were forcibly set to 0 by the system! Fuck a duck!

So to remedy this, there is only one solution (as rewriting the software for the MCU seemed a bit far reached), namely to intercept and tamper with the I2C communication. So I continued my Arduino program, and wrote a program that by using a secondary bit-banging I2C master, could act as a bridge between the monitors’ system and the TA1276AN, but where I could control what was being written, and to which register it would be written. At the same time the program had to deal with the constant status readouts the monitor does, because if something goes wrong, and something doesn’t respond, the monitor shuts off. The program now copies brightness and contrast writes to the RGB registers also, so the OSD actually also function on the RGB line. At the same time, it clears the HI BRT bit (High Brightness Colors) of the RGB contrast register, which apparently make the picture quite dull if enabled (maybe its because it expects the input to have high brightness colors, which it then attenuates a bit) which it is by default. The code was tested on an Arduino ATmega2560 clone, which is rather bulky, but I haven’t gotten the smaller Nano V3 yet, that should be possible to simply integrate somewhere inside the chassis.

Arduino Mega 2560 clone

I will update when I get the Nano, because the code most likely needs some tweaking also. You can find the code here:

To insert the bridge, it is needed to isolate the TA1276AN without disconnecting the other I2C units. On the DT-V100CG there are two 100 Ohm resistors (R6612 and R6613, you can see them to the left of the TA1276AN on the opposite side of the lifted pin 32) going to the I2C pins, which I desoldered, and then attached the Arduino to the bus, by using the pins on another I2C device (which was on the same bus, note that there are/could be multiple I2C busses) and then attached the “local” I2C bus from the Arduino to the TA1276AN. Since I2C requires pull-up resistors, and the internal pull-ups on the ATmega apparently can make the I2C bus slow, I decided to use some 2.7K external pull-ups connected like this:

If needed, 100 Ohm resistors can be placed in series on the line to avoid ringing

So I fired everything up, aaaand presto! Pristine RGB image! Note that this monitor has quite low TVL, and all images are shot with a phone. None give it proper credit.

Mega Man X
Contra III (duh)
The current setup 🙂

I now need to tidy everything up, get the Nano in, to contain everything inside the chassis. Although this was made for the DT-V100CG, any monitor that uses TA1276AN, but isn’t RGB aware, should be able to use this.


After getting the Arduino Nano clones, I basically just needed to find new ports for the secondary I2C bus, and that was it. I soldered the pullups directly to the board, and mounted it in the bottom.

The pullups mounted
The mainboard with I2C and RGB (and sync to input B)

The Arduino is powered from CN6001, where pin 15 is 9V and pin 14 is GND. Pin 15 is then connected to the “RAW” pin of the Arduino, so it uses the onboard 5V regulator for the ATMega328P MCU. GND of the Arduino is then of course connected to pin 14, GND of CN6001.

The cable harness with the small board with the clamping diodes, 75 Ohm terminations and 15 Ohm attenuators.

I decided to use SCART and thus also have 5V blanking, so the blanking pin from the jungle was pulled low by a 51K resistor, and then the blanking attached to pin 16 on the SCART plug. I pulled all cables out the back and 3D printed a bracket to attach it all to, including 2 RCA for the audio out. At the same time I am going to build a small speaker (magnetically shielded) to allow for sound. That’s what the switch is for, select internal sound or pass to speaker.

The bracket. Yeah, it’s orange…

The speaker is going to sit in the corner, dunno how it’s gonna sound, as I haven’t received it yet. 3D files here:

Update 2: The speaker sounds fine. A bit tinny of course, but I put some speaker dampening material whatever its called, white wooly stuff, inside the orange case, which improved a lot. I used a PAM8403 class D amplifier thingy from eBay to drive it, works a charm.