Shiva wrote:
[...]
I really wasn't that serious about
*my* idea - i just thought, hey, any bi-state -used transistor could
*reliably offer 3 states*, but, other than the fact that i could not
instantly think of easy (simple) ways to do the basics, it suddenly dawned
on me: The *heat* would be astronomical! Transistor off - 9theoretically)
inf R, no power to dis. Transistor on - 0R, once again, no power across it
(theoretically). but that *inbetween* state is where things start to
cook... you've suddenly got an R, and, for those of us who can't spell,
that spells "troble...
Of course, i'm making a huge assumption that you're in some way
interested, rather than spamming...
-dim

There's another way, already extensively in use in what's called -
appropriately enough - "tri-state logic." This has three output states;
ON (e.g. pull high), OFF (e.g. pull low) and DON'T CARE (floating). The
difference is that the ON and OFF states are both low impedance, whereas
the DON'T CARE state is high impedance. Its usage is generally simply to
allow the gate (or other device) to "drop out of the picture" when not
needed.

It would be possible for external circuitry to sense that third state,
however, for instance by applying a brief pulse.

But is there a benefit?

Cheers,
Fred

"Fred Nachbaur" wrote in message
...


Shiva wrote:
[...]
I really wasn't that serious about
*my* idea - i just thought, hey, any bi-state -used transistor could
*reliably offer 3 states*, but, other than the fact that i could not
instantly think of easy (simple) ways to do the basics, it suddenly
dawned
on me: The *heat* would be astronomical! Transistor off -
9theoretically)
inf R, no power to dis. Transistor on - 0R, once again, no power across
it
(theoretically). but that *inbetween* state is where things start to
cook... you've suddenly got an R, and, for those of us who can't spell,
that spells "troble...
Of course, i'm making a huge assumption that you're in some way
interested, rather than spamming...
-dim

There's another way, already extensively in use in what's called -
appropriately enough - "tri-state logic." This has three output states;
ON (e.g. pull high), OFF (e.g. pull low) and DON'T CARE (floating). The
difference is that the ON and OFF states are both low impedance, whereas
the DON'T CARE state is high impedance. Its usage is generally simply to
allow the gate (or other device) to "drop out of the picture" when not
needed.


Yeah, but, in a way, *all* gates behave thatway - that's why a digital probe
works... On re-reading what you wrote (above) , you're talking about
9let's take a single "yup"(-|-) gate):
Binary:
high-high
low-low
"no logic" (your "don't care") -????(***)
Your gate:
high-high
low-low
"no logic" (your "don't care") - "no logic" (your "don't care") (***)
So, with your thingy, i'm visualizin' a +-5 supply (or 3 or 2 whatever stuff
is running on now to stay out of the heat...) & a ground rail, 'cos if it's
really floating, then you're dealing with a simple binary gate. If you can
"pull high", you're implying a fairly stable neutral state, while binary
circuits just just pull in one direction - and are stable in 2. If I get
you right, which is a big 8if8. You could be talking about [what I thought
of as] my setup:
bias the binary gate in such a way that the floating input is not floating
at all (with an ideal op amp, it'll swing to high or low, it's only the the
noise on the input that makes it look like 'don't care", but rather prevents
the gate from going 9full) high or (full) low. Now for the good part - the
next gate in line, similarly biased, is only triggered from it's passive
state by (full) high & (full) low, thus you can chain an infinite number
without any probs. And this is just chain-o-thought here, I'm sure there
are mistakes & stupidity involved) The prob here is heat - the things are
idlin' as resistors, which means... bummer 7 high power consumption.


It would be possible for external circuitry to sense that third state,
however, for instance by applying a brief pulse.

But is there a benefit?

Oh, jeesh, this is a mental can of worms... On one hand, if trinary
(forgive the term, kind'o rolls off the tongue better for me...) gates were
used throughout, the parts count would drop dramatically (think in terms of
representing a real big number in base 3 vs base 2, and count the digits).
But. What do we do about clocking? I mean, we crank up the clock 'till
some of the (binary) gates become intermittent, and then roll back a bit,
and let a chunk of code which uses *all* the gates run & see if we glitch
out. At this point, we've reached some kind of a speed trap - we nailed
the overall HF responce limit of the circuit. Assumin' an ideal layout,
we're probably talking the switching time of the transistors, so we'd
probably have to slow down the clock a bunch to be able to avoid taking the
less-than ideal rise & drop time for "don't care" state. There's tons more,
but i *promised* to get some stuff done toay...
-dim (I'm not a real engineer, and no one's willin' to hire me to play one
on TV... Life is hard...)


Cheers,
Fred

Shiva wrote:

(theoretically). but that *inbetween* state is where things start to
cook... you've suddenly got an R, and, for those of us who can't spell,
that spells "troble...
Of course, i'm making a huge assumption that you're in some way
interested, rather than spamming...
-dim

There's another way, already extensively in use in what's called -
appropriately enough - "tri-state logic." This has three output states;
ON (e.g. pull high), OFF (e.g. pull low) and DON'T CARE (floating). The
difference is that the ON and OFF states are both low impedance, whereas
the DON'T CARE state is high impedance. Its usage is generally simply to
allow the gate (or other device) to "drop out of the picture" when not
needed.


Wouldn't it be simpiler to use split rails, then you could have +ve, 0,
-ve for the three states.

I would guess that while it would be more efficient to represent a
number in base 3, additional circuits like adders, and multitipliers
would get more interesting...

--
Nick Gorham

Shiva wrote:



See beggining of thread. Addition is simple, but requires more parts (think
of it as 0, 1 and carry), and it only gets worse from there... OTOH, I'm
not an architecture expert - i think I'm kind'a locked into reproducing
binary. But you're right, it does look like a non-starter...


I think it would be more interesting if silicon wasn't so cheap, as it
is base 2 makes it quite simple. I think the addition would be more than
0 1 and carry, thats just a binary half adder.

The truth table for a trinary half adder would look like this.

| 0 | 1 | 2 |
---------------------
0 | 0 | 1 | 2 |
1 | 1 | 2 | 10 |
2 | 2 | 10 | 11 |

Hey ho, back to valves :-)

--
Nick