RC-II Info

				RC-II Computer Manual and General Information

	The RC-II is an accumulation of separate components, each serving their own individual purpose. Many can be used for different applications, but they are interconnected in such a way to form a computational device. In order to understand the RC-II, a basic understanding of the device as a whole and the individual components is useful, and in many cases required. This is intended as a guide.

						-*{Important}*-

	The entire computer is based off of PTCT and NTCT transistors, and DLAY. The only SWCH that was used, was in the RAM to keep the size down. The connection lines are all METL or INST. There is no FILT/ARAY.

						-*{CONTENTS}*-
I. ................. RAM
II. ................ Decoders and Binary
III. ............... ALU Overview
IV. ................ ALU Components
V. ................. Half Adders, Full Adders
VI. ................ General Component Layout
---------------------------------------------------------------
VII. ............... Commands, Addresses, and Data Processing
VIII. .............. Programming
IX. ................ Path of Program
X. ................. START, PAUSE, RESUME

						-*{Section I.}*-

	The RAM is 14 rows long, each row 8 columns wide. Each cell is equal to one bit. There are 112 cells (14 rows of 8) total. Every cell is identical, and has one pixel of SWCH. If the SWCH is on, that represents a 1. If it is off, it is a 0. Each cell is controlled by 6 INST lines. Each line has a name, A, B, C, D, E, or F. When two of the lines are SPRKed at the same time, for example A and B, an AND gate in the cell is activated, which modifies or reads the state of the SWCH. The combinations of lines, and their function, are listed in the following table:

--=RAM FUNCTIONS=--

 COMBO | FUNCTION
 ------|---------
 A+B   |  READ
 C+D   |   ON
 E+F   |  OFF

	So far, 6 lines have been mentioned. However, they are useless on their own. There is still one more line, called the G line. This line carries the data after A and B are SPRKed and read the state of the SWCH.

	On it's own, a line of RAM is simply an 8 bit binary number. However, the RC-II is wired so that each line is divided in half. The left side is used for addresses, which will be explained in detail in section VII. The right side of a line is used for data, which the ALU will process. This, too, is explained in section VII.

						-*{Section II.}*-

	All of the data in the RAM is in binary. *-If you do not know what binary is, or need a refresher, skip to the end of this section-* This data must be decoded, so that it can be used as an actual, physical location. For example, the data 0001 must be turned into wire 1, and data 0111 must be turned into wire 7. This is used for deciphering addresses and commands. It will also be used for deciphering the binary output of the full adder, explained later in section V.

	There are two decoders used in the RC-II. The first is used for deciphering the binary output for addresses, and accessing the next address. The second is used for deciphering commands. Commands and addresses are explained in section VII.

	Decoders are fairly simple in theory. They must simply convert binary to normal numbers. They are actually much more complex. The binary input is stored temporarily, in simple component used for storing, then reading the data in series. This component, in itself, is four identical modules which "snap" together. Above this component, is a set of four counters. When started, they output a pulse every 12 frames for however long they are. There are four lengths, 1, 2, 4, and 8, for the actual number the binary data represents. These counters send outputs to the physical counter. This simply takes one pulse, and adds it to the last. If one pulse is made, the first wire is opened. If a second comes, the first wire is closed and the second is opened. Etc, etc, up to 14.

	Suppose the binary is 0101. The component stores 0101 in itself, one bit in each module, and sends a pulse to the first module. Typically, binary is read 8-4-2-1, but the architecture of the decoder is 1-2-4-8. This will be explained. For the sake of the example, that will be ignored. The first module reads a 0, so sends a pulse to the second module. The second module reads a 1, and sends a pulse to the counter above it, which happens to be four (Due to actual architecture, would be two). The four counter emits four pulses, which are sent to the physical counter, The physical counter opens and closes wires as the pulses come, until the fourth. It now has the fourth wire open. The counter, on it's fourth pulse, also  sent a pulse to the 3rd module, which reads a 0, sending a pulse to the last module. The last module reads a 1, and starts the counter above it, which is a 1 (Architecture eight). It sends one pulse out, which opens the fifth wire on the physical counter, and closes the fourth. It also sends a slightly delayed pulse to the read function on the physical counter, which makes the physical counter SPRK the open wire. Once the data is used for what it needs to be, the physical counter is reset. In this way, the entire system can be re-used infinitely.

						--=ARCHITECTURE=--

	The architecture of the decoder may seem silly, however it makes sense in the entire system. This diagram will hopefully help.

  --=KEY=--
SYMBOL|MEANING
------|-------
   |  | Vertical wire section
   _  | Horizontal wire section

     --=DIAGRAM=--

RAM DATA          DECODER
||||              ||||
8421              1248
||||______________||||
|||________________|||
||__________________||
|____________________|

This shows how the wiring flips the numbering.

						--=BINARY=--

	Binary is a fairly simple concept. Computers, at their most basic level, are simply electric pulses, or no electric pulses. An electric pulse is a 1, and the absence of a pulse is a 0. Everything in a computer is 1's and 0's. This means complex and large numbers must be created using only 1's and 0's. There are two options. The first, is to have hundreds of wires, one for each number. The second, is to develop a code of sorts, that uses less space. Binary is also very useful, because it provides a way for computers to do math using simple logic.

	The following chart shows a number, then how to write it in binary. *0000000000000010 is the same as 0010 or 10*

--=BINARY CHART=--

--=KEY=--

000|1| a one here, is a one
00|1|0 a one here, is a two
0|1|00 a one here, is a four
|1|000 a one here, is an eight

This can also be represented by:

8421

The corresponding number is in the position it's represented by.

By adding a combination of 1, 2, 4, and 8, every number from 1-10 can be created.

NUMBER|BINARY CODE
------|-----------
1     | 0001
2     | 0010
3     | 0011
4     | 0100
5     | 0101
6     | 0110
7     | 0111
8     | 1000
9     | 1001
10    | 1010
------------------

	If you can understand that, binary becomes fairly easy to read. If you have some crazy number, like 10001011010111, there is a simple rule for finding out what numbers are represented by each 1 or 0. Each time you go another 0 or 1 from the right side, double the value. 1 doubled is 2, 2 doubled is 4, 4 doubled is 8, 16, 32, 64, 128, 256, etc. By adding a combination of 1, 2, 4, and 8, every number from 1-15 can be created, at which point 16 is required. So on, with bigger and bigger numbers.

						-*{Section III.}*-

	An ALU is an Arithmetic Logic Unit. It performs all of the computations inside of a computer, and in the RC-II is one of the most complex systems. The ALU in the RC-II has 3 main sections. The flip-flops, the memory, and the full adder.
	The path begins with the flip-flops. The first flip-flop sends the data signal from the RAM to the command decoder. If the command is ADD (More about commands in section VII.), then the first flip-flop is activated. Now, the first number is sent through the first flip-flop, and into the second. The second flip-flop sends the first number to half of the memory bank. It then activates, so when the second number comes through it is placed in a separate section of the memory bank. The memory bank reads the two numbers at the same time, and sends them to the full adder. The full adder completes the addition, and the sum is output after 122 frames. At the same time, the flip-flops are reset and the memory bank is cleared. Section IV. explains the parts in detail.

						-*{Section IV.}*-

	The flip-flops used in the RC-II are transistor-based, so when they change states, they must be continually powered to keep the state changed. This is provided for, using a power wire.

--=FLIP-FLOP=--

        __|__OUTPUT2
       |  |
INPUT--|  |POWER
       |__|__OUTPUT1

	In order to keep them changed, they require a constant power source. This was achieved by using a simple ON-OFF power source, controlled by PTCT and NTCT.

--=POWER BOX USAGE=--

      ON
 _____|____
|          |__PWR OUT
|          |
|          |__OFF
|__________|

	The memory bank is a simple, 8 bit wide temporary transistor storage unit. The left 4 bits hold the first number, the right 4 hold the second. The full adder will be explained in section V.

						-*{Section V.}*-

	Full Adders anf Half Adders are the basis of computer math. They take binary inputs, and add them together. A full adder is made of 7 half adders.

						--=Half Adders=--

	Half adders are extremely simple. They take two input, and compare them to create one output. There are two outputs. A Sum, and a Carry. Here's a table of the binary math they preform:

ADD|SUM|CARRY
---|---|-----
0+0| 0 | 0
0+1| 1 | 0
1+0| 1 | 0
1+1| 0 | 1

This can also be shown as:

0+0= 0 and carry 0
0+1= 1 and carry 0
1+0= 1 and carry 0
1+1= 0 and carry 1

	The half adders in the RC-II were designed to be placed side by side, to conserve space and organization. The have to inputs, and two outputs. The sum is the output on the right. The carry is the output on the left. Other than that, they are practically symmetrical in architecture. Inside of the half adder, the central column is the carry, and either side is sum. If the carry is activated, it blocks the sum. Both sums must be on for the carry to activate.

						--=Full Adders=--

	Full adders are a combination of half adders that can add complete binary numbers. So instead of 0+1 = 1 carry 0, it can do things like 0110+0101 = 1011. The RC-II has one full adder. The general layout is simple, as are the connections. I shall only explain the layout. On the top, are four half adders, and below them are three half adders. The outputs of the top four connect to the inputs of the bottom three. The carries of two of the bottom three, connect to the inputs of the one directly to their left.

	The total output of the full adder is output to a simple display, where the bits of the sum have a light light up directly above the represented binary number.

						-*{Section VI.}*-

COMPONENT         |LOCATION
------------------|---------------------
RAM               |Left side of screen (X<164)
Decoders          |1: > (208,67)|2: > (295,120)
Programming Pads  |Right of RAM, "WRITE" and "CLEAR"
ALU               |Right of programming pads, below decoders
Full Adder        |Right of programming pads

						-*{Section VII.}*-

	Commands, Addresses, and Data Processing are all useful for programming. We will begin with commands.

						--=Commands=--

-*Commands with a * are not yet operable*-

COMMAND|BINARY|SYNTAX
-------|------|------
ADD    | 0001 | ADD with address of 1st #, Address of 2nd # on 1st, WHERETO
*SUB   | 0010 | SUB with address of 1st #, Address of 2nd # on 1st, WHERETO
*MULT  | 0011 | MULT with address of 1st #, Address of 2nd # on 1st, WHERETO
*DIV   | 0100 | DIV with address of 1st #, Address of 2nd # on 1st, WHERETO

	Commands are placed on the right side of the RAM.

						--=Addresses=--

	Addresses are on the left side of the RAM. The say which address to go to next. Program using binary, addresses range from 1-14 and are shown next to programming pads.

						--=Data Processing=--

	Data is processed in two ways. It is either sent to a decoder where it becomes physical location, or is sent to the ALU where it is added. Addresses are ALWAYS processed by a decoder. Data on the right side of the RAM can be processed by either the command decoder or the ALU.

						-*{Section VIII.}*-

	The RC-II has two pads designed for easy programming. The first is the WRITE pad, the second is the CLEAR. To write a program, clear all of the data from the RAM using the CLEAR pad. Use a 3x3 square pen for specific bits. To write your new program, use the WITE pad. Begin at address 0001. On the right side, write the command. On the left side, write the address you want to go to next. Reference section VII. for commands and syntax.

	The programming pads do have a few limitations. Program one row, and wait 10-20 seconds before going to the next. The NTCT in the RAM needs to cool, or else you may add extra data to your previous row. This can cause major problems when attempting to execute your program.

						-*{Section IX.}*-

	This is a basic path of the RC-II executing a program.

START(Reads 0001)->0001->DATA DECODED->PROCESS COMMAND->GOTO NEXT ADDRESS

						-*{Section X.}*-

	The START button is bright green within darker green. It places address 1 in the decoder (Or adds one to the current address -- This is not recommended, as problems may occur).

	The PAUSE button is bright red within dark red. It keeps the next address from being read.

	The RESUME button is bright green within bright yellow within dark yellow. It resumes the program after it has been paused.

				Built and produced by RCAProduction
				Questions? rcaproductionmaster@gmail.com