You should probably read back the entire thread
The processors are not causing any problem at all, the issue is purely the ULA because they have some non deterministic internal value which make them start from one out of four different values.
When the ULA are correctly synced - this requires the use of a common clock signal, as well as some fancy throtling on the individual input clock signal they are then perfectly in sync, and just merging the wires works perfectly in RGB. No need to use the composite at all.
The challenge is not really in merging the output, it's more in finding the most bangs for the bucks, which for me at least implies to be able to still be able to run normal oric software on one machine and have it work normally: It should still be an Oric at the core.
The problem of this approach is that basically it makes it impossible to just use one machine to output a normal Oric game output.
A few weeks ago I formulated the question like that to some friends:
What would be the simplest/economical way to implement the following digital circuit:
Let say we have four TTL inputs (each is either 0 or 1) names A, B, C and D.
Using a simple OR gate, I can get a simple TLL mixer that outputs a 0 or 1 depending if any of these four inputs is non null, so we get a 0 output if we have all 0 inputs, and we get a 1 if at least one of the inputs is non null.
So far, so good?
What if... I wanted to get intermediate values?
Say, I still want to be in the same 0 to 1 range of voltage, but I'd like to have intermediate values based on the number of inputs that are set to 1?
- If all the inputs are 0, then we get 0
- If one input is 1, then we get 0.25
- If two inputs are set to 1, we get 0.5
- If three inputs are set to 1, then we get 0.75
- And finally if all the inputs are 1, then we get 1
How would you achieve that without using modern components?
Now, what if... I wanted the same thing, but not in the same order:
- If all the inputs are 0 -> 0
- If one input is 1 -> 1
- If two inputs are set -> 0,5
- If three inputs are set -> 0.75
- If all four inputs are 1 -> 0.25
Is that still doable using small component logic (gates, transistors, resistors, ...) or does that require something much more complicated?
Thanks to anyone who can provide some hints on how that could be achieved, or some documentation, or even "names" of things, because I've no idea how to even search for it.
It's kind of DAC, but using the number of inputs as a value instead of the binary representation of the inputs...
That's basically what I came up with, which would allow the largest flexibility:
- Possibility to have any machine able to display a fully compatible Oric image just by itself
- Which imply that you can use two machines to draw the same thing twice faster, and with four machines you can do that four time faster
- and when you add the possibility of multiple machine actually changing the same pixels, you get intermediate shades of colors
So, it's not optimal in term of what could be achieved with this number of bits, but it's manageable in term of programming, a good example would be a game with a scrolling playfield and a score board: The score board does not move, so you can use overlapping layers on the four machines to generate a very colorful and detailed board, while the playfield itself can be drawn by two machines to be twice faster, and two other machines are just in charge of displaying sprites.
Just not sure how to achieve that in hardware