VGA lcd pins

[mrn]

Hello, this is my first post on this forum, I just had a question regarding the pins on a VGA connector

How does a vga connector transmit signal to all the pixels in a lcd monitor, there being thousands of pixels and only a few vga pins?

Crystalfontz LCD Blog

Looking for additional LCD resources? Check out our LCD blog for the latest developments in LCD technology.

 

[cosmicvoid]

The same way a coax cable sends millions of pixels to your TV set:

One at a time.

 

[mrn]

So it sends one pixel then that pixel gets stored in memory in order to stay on while all the other pixels get sent?

or does it just do it really fast, without the need of memory?

also how does it know witch pixel to light up just based on a single signal? because you have to have a signal for power and a signal for ground

also how does one signal know witch pixel out of thousands to light up?

 

[mrn]

sorry(bump)

 

[cosmicvoid]

Do you not know how to use google or wiki?

http://en.wikipedia.org/wiki/Video_Graphics_Array

 

[mrn]

Sorry, yes I do

 

[mrn]

Partial Solution

Okay so I did some research and I came up with a partial solution but on a much smaller scale there is a crude image here: (you can click it to make it bigger)

So now my problem is I have 9 control signals to deal with, how do I get around this, if possible?

I should note: i'm assuming whoever reads this is familiar multiplexing, that is why I did not explain the diagram.


Thanks for help

 

[cosmicvoid]

Well, I'll just ask two questions:

1. What does the mux diagram have to do with VGA?

2. What is the actual goal that you are trying to accomplish?

 

[mrn]

Sorry, yes the original idea was to get help on reverse engineering how a lcd panel works, so that I could use the same concept but instead replace the pixels, with something else like a motor or something.

Basically what I am trying to do is have a big grid probably 128x128 to start with, which is made up of motors.

And the system would go threw and turn on one motor at a time for just a split second, doing so very quickly.

In fact it may not even be motors that I use, but instead a solenoid or something.


So I realize this is a display forum presuming by the title (crystalfontz.com) but I thought this would be a good forum to get help on how a lcd panel is all wired up, so I could use this concept.

 

[cosmicvoid]

The way that LCD displays work is not very closely related to what you are trying to do, so I don't think that will be of much help.

You are just aiming for a muxed array, but I suspect not one that is refreshed at high frequencies, like displays are.

Basically what I am trying to do is have a big grid probably 128x128 to start with, which is made up of motors.

Wow, you want an array of 16384 motors (or "some kind" of electromechanical device)? Do you plan a parallel access, with an 8-bit bus and latches for row and column addressing? Or, perhaps a serial access, where the row & column data are shifted into a long register, and then latched?

Have you given any thought to having 16000 high current drivers? And for inductive loads, you'll need to have clamp diodes across each device to avoid back-emf killing your drivers.

turn on one motor at a time for just a split second, doing so very quickly.

Are you implying that the motors will be PWM controlled? That would complicate your software considerably.

Well, all of this is pretty simple, concept-wise, but the size of the array seems pretty huge for discrete loads (as opposed to something compact like pixels). Perhaps you are making a super-robot.

 

[mrn]

lets break this down to a smaller level, and then we can talk about the 128x128 once I have the concept down

so if I did a 8x8 grid 16 8 positive and 8 negative,

I could use a 1:16 demux right? with only one input from the parallel port?

 

[cosmicvoid]

... if I did a 8x8 grid 16 8 positive and 8 negative ...

I'm guessing that the number "16" in your post has no meaning... at least none that I can figure out. As for "8 negative", I also guess that you dont really need a negative voltage; I think you are going to want 8 source drivers and 8 sink drivers. The source driver supplies a path to power; the sink driver supplies a path to ground.

... I could use a 1:16 demux right?

No, not for an 8x8 matrix. You will need two 1:8 demuxes.

... with only one input from the parallel port?

No. For each 1:8 mux you would need at least 4 bits to control it, maybe more. Three bits for the 1-of-8 address, one bit for data (state of the output), maybe one bit for output enable. Same for the other 1:8 mux. Unless you decide to use serial access (i.e. shift registers).

Now, that setup will allow you to have 1 of 64 devices active at a time. If you need to have more devices in the array active, you would have to have latching outputs on each of the muxes. Then, there's two ways to interpret that statement. One: the address and data state are latched, but only one output is active at a time. Two: the latches are on the output of the demux, so that any or all outputs could be active at once; in which case you probably wouldn't use a demux, just an 8 bit latch for each axis of the array. It all depends on what you want to accomplish.

Conveniently, sink and source drivers are commonly available with 4 or 8 drivers per package, assuming you don't need to switch large amounts of current.

 

[mrn]

So then a shift register would be the better more simple way to do? i'm thinking of using some 74HC595's http://www.taydaelectronics.com/74h...ster-ic.html?gclid=COG_1bT7u7YCFeZxQgod5HIAHA


you can "daisy chain" them or link them up to controll virtually unlimited number with just 3 pins, data, clock and CS

 

[cosmicvoid]

So then a shift register would be the better more simple way to do? ...

Yeah, probably serial is the simpler way to do it; in exchange for simplifying the hardware, it complicates the software.

Its interesting to me that you have kept your goal details hidden; the kind of info that would help choose the methodology of the design. For example, do you really need a matrix (array) design? No reason to have both source and sink drivers unless you require a matrix design. With serial interface, that seems unnecessary. Here is a sample of a serial driver chip, just to give you an idea of what I'm thinking of:

http://www.freescale.com/files/analog/doc/data_sheet/MC33996.pdf

The HC595 is so crude, comparitively, and has no power drive capability. Since you posted in the parallel port interface forum, I'm guessing that you intend to control your project from a PC. Bit-banging serial hardware from a parallel port is kind of tedious, software-wise. But you've said nothing about what your project is; you're just asking theoretical design questions, which seems a waste of time (and a bit boring ).

 

[mrn]

I apologize, basically its exactly what I've explained, just a grid of solenoids or valve's, that release fluid.

what do you mean by source and sink drivers?

My plan as far as software was use python first of all using the pyparallel module, and second I was planning on kind of writing a back end class or functions that I could then use to quickly beat out the rest of the program, but I will go into that later.


I'm thinking that if I do a 64x64 grid, I would need 8 74HC959's witch I would chain together, then latch out only 2 high bits per output, so for example:

row bits
000100000000000000000000000000000000000000000000000000000000000

column bits
000000000100000000000000000000000000000000000000000000000000000

Hopefully this makes sense

it would load the first 8 bits so for the row bits it would be 00010000, and then the 9th 0 would drop over onto the second 74HC595 and so on. the same for the column bits aswell.

I know this would be somewhat slow and tedius, but for what I am doing I dont need it to be crazy fast or anything.

 

[cosmicvoid]

... what do you mean by source and sink drivers?

I touched on that in post #12, above. But if you need more info you could always ask google.

I'm thinking that if I do a 64x64 grid, I would need 8 74HC959's witch I would chain together, then latch out only 2 high bits per output, ... snip ...

Actually, you'd need 16 74HC959s, 8 for each axis. Nothing you've said so far requires the matrix method. You don't mention drivers, but I guess you know the 74HC series cannot switch more than a few mA, so you'll need drivers. One downside to the matrix method is needing both source and sink drivers, which adds a lot of IC packages and also increases the voltage drop a bit.

Seems to me a serial one-sided (meaning only a sink driver) approach would be most efficient. But you should do it however you like. 4096 valves, really? I guess thats easier than 16384 valves/motors.

 

[mrn]

So if i'm understanding this right: source drivers are put after the 595's so that when they get the output signal from the 595's they take the external power that they tapped into and pulse a bit of it into the grid? and the sink driver handles the ground current?


Yeah your right I would need 16 595's


what do you mean by serial one-sided assuming you haven't explained it already?

I'm open to better ideas

 

[cosmicvoid]

I get the feeling that I'm writing in a foreign language, as you keep asking things that I have already explained. I guess my posts are not very helpful to you. I bet you didn't even look at the driver data sheet I linked to in post #14.

 

[mrn]

sorry, yes I did