cga to vga converter uPython

There's a website listing monitors that support your resolution: http://15khz.wikidot.com/

I think it's far more likely that you'll be able to source a monitor if you search long enough on eBay, than to convert the sync rate with a Pico.

If you were to use a Pico, you'd need to figure out how to convert the analog signal in to digital for the Pico to read in, and then figure out out how to send out an analog signal (that latter part is slightly easier, it's been done before I expect). But none of that will work with native microPython (if I assume you've already searched for a library for it, and not found it), and will likely require assembler coding (for the internal units known as PIO). It's a steep learning curve if you need help with everything you've listed above. 

There may be other ready-made converters out there.

Sounds like an interesting project.  It would be interesting to see the finished product. 

Are you looking for something like this RGB to VGA adapter? They cost about $1.

I think they mean the old IBMPC Color Graphics Array RGBI TTL output

https://en.wikipedia.org/wiki/Color_Graphics_Adapter#DE-9_connector_for_RGBI_monitor

RGB + Hsync Vsync. the adapter should contain 5inputs the one youl listed looks like 3 inputs

- its an industrial equipment so no analog signal needed just low or high

-  one color as it only shows text is acceptable

- its showing text i think the 320x200(my predicted resolution) could be shrinked down to like 120x80 or something

- as of my own im thinking about leaving the Vsync and leaving the Hsync also, but one interrupt driven pico input could make in half period a second trigger so in this way the Hsync is doubled. with signal generator i was able to sync up the vga monitor, but the left part of the original screen is also written on the original right part of the screen so its messy but at least i can see the source equipment is working, but line doubling like that isnt really a solution i need to part it so if i could make a fast enought program to read one line and write two with the information from the one but double freq/half period

- my second idea is to read a whole image then visualise with a resolution as i want as driving a vga display is not that hard, but im not sure what kind of variable library could hold up the whole image data as im new to python, i dont even know which way is proper for one line bit transforming

one color possibly reduced resolution is my first goal

- im also thinking about making a trigger driving a flipflop at half sync period then drive 2 monitors with half part of the original signal but its a pretty messy solution

sorry the other reply was for the original comment.

i looked up your link and hsync is pretty similiar, but vsync is 63hz not 59.xxx

the sync is ttl level

rgb also ttl level

mine has no intensity output and rgb signals look like low high

possibly you are right and my machine was derived from this standard, its a cnc mill sinumerik controlled operators panel

You might be able to pick up an Extron VS 304 for next to nothing. They could handle 15kHz RGBHV and scale to VGA.

https://www.extron.com/product/dvs304

RGBHV2VGA is a bit more expensive $7-$8

If it's just 1-bit data (i.e. R/G/B are all the same, and only two values) then that's a lot easier.

However, I'm not sure why you think microPython will work here. It's too slow for this. If you wish to do it with a Pico, then you'd ideally need to read up on the Pico's PIO (Programmable Input/Output) feature, and learn how to use that. With that, it could be fairly straightforward to do what you want, perhaps translating each raster line to two, for CGA->VGA, or writing to frame buffers, you have the memory for that option too. You'll be in a better position to decide that once you've use the PIO capabilities a bit. Note that there are two PIOs, so you can use both if it simplifies things. I suspect you may need to use two since each one can only have a limited amount of instructions.

So, the language to read up on and experiment with is PIO assembler, plus a bit of C (other languages are possible, but C would be easiest) for any setup code as required. You could even drive a LCD screen. If you're completely new to all this, all I can suggest is do some simpler experiments first, and get used to using an oscilloscope to help monitor and debug your PIO code.

As mentioned before, picking up an off-the-shelf 15kHz compatible monitor would be the simplest option though.