Subject:
|
Re: Mechanical Memory for Computing
|
Newsgroups:
|
lugnet.robotics
|
Date:
|
Wed, 25 Jun 2003 12:23:53 GMT
|
Original-From:
|
Steve Baker <sjbaker1@airmail+saynotospam+.net>
|
Viewed:
|
808 times
|
| |
|
|
Brian H. Nielsen wrote:
> The red #12 axle functions as a write-protect mechanism. In the position
> shown, the black axles are prevented from sliding and the byte is
> write-protected.
Ah! Very clever! That way we can unlock the memory when it's in the "write"
mechanism and lock it when it's being read or moved around inside the machine.
That cleanly solves my 'friction' problem.
> The 4-bit byte is a function of #12 axles being the longest available, but
> the design is extendable to link multiple bytes together into longer length
> words.
The problem is that the spacing between the bits will need to be kept exactly
constant in order for the *serial* reading and writing of a byte to be do-able.
We talked a bit about this a couple of posts ago - but essentially, the machine
is proposed to be a 1 bit wide machine internally (at least inside the adder unit),
so the bits of one byte of RAM will need to be shuffled in front of the write
head one at a time.
However, maybe we can figure a way to unprotect each bit one at a time as it
enters the write mechanism...or better still, *AS IT IS BEING WRITTEN*.
That would eliminate your length restriction - and also resolve the problem of
the spacing because each bit would now be identical.
Perhaps, all we need is to have the 'write head' do something like rotate the
movable axles through 90 degrees as it moves them between the '1' and '0' positions,
rotating it back through 90 degrees when it's done.
> The molecular level RAM design included multiple bytes stacked up and a
> method to select which one was being read/written, but it involves additional
> structure containing flexible rods for which there is no suitable LEGO
> counterpart. I am working on alternate methods, but I am not hopeful at this
> point in time.
But we can bolt them into a rigid array and simply move the entire stack of
bytes up and down to select which byte is being addressed - and left and right
to pick which bit out of that byte is to be read or written.
For program storage, it would probably be desirable to read out all eight (or
more) bits from each byte in parallel - but that's a much easier prospect.
---------------------------- Steve Baker -------------------------
HomeEmail: <sjbaker1@airmail.net> WorkEmail: <sjbaker@link.com>
HomePage : http://www.sjbaker.org
Projects : http://plib.sf.net http://tuxaqfh.sf.net
http://tuxkart.sf.net http://prettypoly.sf.net
-----BEGIN GEEK CODE BLOCK-----
GCS d-- s:+ a+ C++++$ UL+++$ P--- L++++$ E--- W+++ N o+ K? w--- !O M- V-- PS++ PE- Y-- PGP-- t+ 5 X R+++ tv b++ DI++ D G+ e++ h--(-) r+++ y++++
-----END GEEK CODE BLOCK-----
|
|
Message has 1 Reply:
 | | Re: Mechanical Memory for Computing
|
| (...) Since the design is scalable, you could scale it *down* from a 4-bit byte to a 1-bit byte. Now each bit is individually write-protectable. I believe a better way would be to keep the 4-bit byte length for main storage and transfer the value to (...) (21 years ago, 25-Jun-03, to lugnet.robotics)
|
2 Messages in This Thread:
 
- Entire Thread on One Page:
- Nested:
All | Brief | Compact | Dots
Linear:
All | Brief | Compact
|
|
|
|
