
One-Bit Computing at 60 Hertz - Tomte
http://laughtonelectronics.com/Arcana/One-bit%20computer/One-bit%20computer.html
======
floatingatoll
If you find this circuit appealing to consider, Shenzhen I/O may be of
interest.

[https://news.ycombinator.com/item?id=12660253](https://news.ycombinator.com/item?id=12660253)
[https://news.ycombinator.com/item?id=13041538](https://news.ycombinator.com/item?id=13041538)

I was reminded by the 4099 output -> input as a form of 'register', which is
used in SI/O ( _and_ TIS-100).

~~~
gnulinux
Agreed Shenzhen I/O is a very nice game. It's more of a 2-bit, 3-bit than just
1-bit (I think the first 2 microcontrollers are truly 1-bit but later ones are
2-bit, and you can store state in p registers) (also not quite bit as IO is
analog) but your circuits look very similar to the one in OP. I bought it off
of Steam when there was a sale and it was only $5; best $5 ever spent!

------
kazinator
> _The machine always jumps from one instruction to the next. It doesn 't know
> how to "fall through" to the "next" address because it has no program
> counter and no ability to count (compute an increment)._

That is very similar to the logic state sequencer designed by Wozniak for the
Apple II disk drive controller.

------
jacobush
This is such genius. I actually understood how it works, but I think I would
get a headache "programming" it.

~~~
Dr_Jefyll
>I think I would get a headache "programming" it

One-bit creator here. I'm surprised by how often people make comments like
this. Is it the dual jump destinations which seem so confusing? All you need
is to ignore one of them, assuming you'll "fall through" instead. This is
noted in the article. "instructions generally do tend to get stored in
sequential order, and, as a matter of coding style, conditional branches very
often do specify address+1 as one of the outcomes. The assembler makes it easy
to use the familiar branch, else fall through to the instruction at address+1
arrangement. "

Thanks for posting, Tomte. This and other projects of mine have appeared on HN
before.

Edit: but don't use HN's search to find Dr_Jefyll. That's an f there, not a k;
but HN's search seemingly can't be convinced of this.

~~~
mbreese
I somewhat understand what's going on, but it might be helpful to have an
example or two of what you actually used this for. Like... what kind of
functions did you add to the printing press?

Is the tradeoff here if you use a "simple" 1-bit processor, you have to have
more complex data/instructions? Meaning, because you only have 1-bit, there is
a lot of jumping around. This means that for everything that you'd want to
compute, you'd have to have the instruction flow in memory, instead of relying
on more OP codes/instructions for the microprocessor?

This all sounds really interesting, but I'm having trouble completely wrapping
my head around it.

~~~
Dr_Jefyll
> it might be helpful to have an example or two

Apologies. The original source code from the early 1980's is stored on a non-
DOS floppy. Maybe someday I'll retrieve and publish it. But meanwhile here's a
taste:

One of the tasks is to activate a solenoid to ink up the lithographic plate
after a certain number of revolutions of the press. That number, range 0 to 9,
is read from a 4-bit, binary weighted thumbwheel switch which has been set by
the press operator.

The code uses 1 instruction to test bit0 of the thumbwheel switch. If bit0 is
true, we fall through to another test that waits (jumps to self) until the
tachometer pulse goes high; this eventually falls through to another test that
waits for the tachometer pulse to go low. So, that's one revolution. But if
bit0 of the thumbwheel switch is false, we jump past all this (ie, don't wait
for one revolution).

Bit1 of the thumbwheel switch is similarly tested, except the tach must go hi-
lo twice (2 revolutions); and so on for bits 2 and 3 (4 revs and 8 revs).
Then, with all the counting complete, the solenoid gets turned on.

I have simplified somewhat; actually the rev-counting portion is a subroutine,
called from two different places in the code. The (very primitive!) subroutine
calling convention is explained in the article. HTH.

~~~
mbreese
That does help! Thanks for writing this up. It’s really quite interesting.

------
bctnry
It somehow reminds me of BitBitJump[1].

[1]:
[https://esolangs.org/wiki/BitBitJump](https://esolangs.org/wiki/BitBitJump)

