ing.-büro bechler halle


D 06108 Halle a.d. Saale   ibh@ebechler.de

- VerySimpleLogicSimulator


©2008 Ing-Büro Bechler Halle

nor is not suitable to develop commercial Circuits but to simply and quickly simulate and verify all that Schoolbookstuff dealing with basic logic Elements. So you won't find big libraries with a lot of Circuits in it with the need to learn their Handling and Usage not even Autorouting for automated Wiringlayout.
Only five Elements  NOR, NAND, OR, AND and XOR and some additional Tool devices for generating, storing and visualizing Inputs and Outputs are available.
We do not use an academic claim in the arbitrary editable Tutorial's Samples following but to become familiar with the Theme and the usage of the application.

If you need some more, you build it by yourself in using the native Elements, add  In- and Out-Clamps and then use it in unlimited even nested Copies in other Circuits.
All your Circuits are saved in Definitionfiles which are simple ASCII-Files editable with every Textapplication like Window's Notepad.
Setting a bit-Value is done by a Mouseclick, to 'wire' Clamps drag it, and your Circuit will always immediately reflect its Consequences.

If you do not have a nor - Very-Simple-Logic-Simulator Application on your Computer you may want to download nor for Windows-XP/Vista/7 first
to play with the SamplesDOWNLOAD (1,6MB)

(Once installed please make sure that you set one of the three Folders in Menu/File/Options to the Samples-Location that is by default: "C:\Program Files\ibh\nor\Samples")

Der nor - Very-Simple-Logic-Simulator
für Windows-XP/Vista/7 ist ein sehr einfach bedienbares Logik-Simulations-Programm für den Informatik-Unterricht und das Selbststudium.
Mit der Anwendung können keine kommerziellen Schaltungen erstellt werden.
Aus NOR, NAND, OR, AND u. XOR-Elementen werden hingegen schnell funktionsfähige Schaltungen "aufgebaut" und ausprobiert.
Die Schaltungen werden mit der Maus editiert und reflektieren stets ihre aktuellen Zustände.
Die eigenen Schaltungsentwürfe werden in Textdateien gespeichert und können anschließend in anderen Schaltungen als Module verwendet werden.
Die Verschachtelungstiefe ist dabei beliebig.
Für die entstehenden Baum-Strukturen stehen Übersichten zur Verfügung.
Es können Zustandstabellen angezeigt werden.
Die erstellten Modul-Definitions-Dateien können ausgetauscht und in Modul-Bibliotheken verwaltet werden.
Schüler können verteilt an unterschiedlichen Aufgaben eines Projektes arbeiten und in beliebig vielen Fenstern Schaltungen gleichzeitig anzeigen und editieren.
Es werden einige zusätzliche "Tool-Elemente" angeboten, um Standardaufgaben zur Speicherung und zur Ein-/Ausgabe zu vereinfachen.
Die im folgenden Tutorial verwendeten, beliebig editierbaren Beispiele erheben keinen akademischen Anspruch, sondern dienen lediglich dazu, mit dem Thema und der Bedienung des verwendeten Programms "nor" vertraut zu machen.

Falls Sie noch nicht nor - Very-Simple-Logic-Simulator für Windows-XP/Vista/7 installiert haben, können Sie hier die aktuelle Version 'downloaden' (
DOWNLOAD (1,6MB) ), um die Beispiele direkt aus dem Tutorium heraus aufzurufen.

(Bitte stellen Sie sicher, daß einer der drei Vorgabe-Ordner unter Menu/File/Options auf das Verzeichnis für die Beispieldateien gesetzt ist. Standard: "C:\Programme\ibh\nor\Samples")



©2008 Ing-Büro Bechler Halle

Remember following Functions to create or delete Elements on your 'Board':

    Insert an external Input-Clamp on the left Side of the Board so that your Circuit can be used by other Circuits.

    Insert a Standardelement (NOR, NAND, OR, AND, XOR,  Source, Meter, 7-Segment-Display, RAM256x8, Shift-Register, Random-Generator, Clamp, par. In-/Output). (also: [Ins])

    Insert  a self-defined, 'self-made' Circuit as Element from its Definitionfile. (also: [Alt]+[Ins])

    Insert an external Output-Clamp on the right Side of the Board to later connect with other Circuits.

    Use corresponding Buttons to delete the current or marked Elements. (also: [Ctrl]+[Del])

Get Summeries of the available Elements with the three following Sample-Files:

Make yourself familiar with the native logic Elements i.e. with _The Logical-Elements_.nor :

The logic Elements  The logic Elements

These are the available Tool-Elements for various Tasks _The Tool-Elements_.nor :

The Tool-Elements  The Tool-Elements

and here are several 'Clones'/nested Elements _Several Clones_.nor :

Several 'Clones'  Several 'Clones'

©2008 Ing-Büro Bechler Halle


All current computing machines are huge sets of logic Elements with at least NOR(not or)- or NAND(not and)-behaviour which has been realized with several Techniques during time. For studying purposes you might get a limited amount of them in small cases with jack plugs for the connections. The nor - Very-Simple-Logic-Simulator offers you to connect an unlimited amount of such Elements in its reusable 'virtual' circuits.

Here are some examples for logic Elements in the real world.

Simple Switches-array with AND-Behaviour:

The Output (Lamp "y") of that circuit will burn (go "high") if Input-Switches "x0" and "x1" are closed ("high") and a battery "B" is connected.

Switches-array with OR-Behaviour:

It's Output will be "high" (Lamp "y" burning) if at least one of the Input-Switches "x0" or "x1" is closed.

The Inputs of above circuits must be set manually by their switches and Output is indicated by a light.
But we intend to connect such circuits for getting more complex variations. Thus we extend them with the ability to be set in their native way: electrically. To do so we use switches that can be operated by electromagnets (relais).

An AND-Module with relais:

If both relais are driven via Inputs "x0" and "x1" with a current from a voltagesource also connected to "B" then Output "y" will be set "on" (or "high") too.

Here a variation with OR-Behaviour:

Setting one Input "high" suffices to fire Output.

In practise you will find circuits using semiconductors as switches gathering a huge amount of them on one substrat.

NAND(not and)-Gate with two transistors and a resistor as voltage divider:

Since not both transistors are driven output "y" remains "high" (on "B"-voltagelevel).

NOR(not or)-Gate with transistor
and two diodes:

Output will go "low" (ground-voltagelevel) if its base is set via one of the diodes (which isolate the inputs against each other).

Notice: In nor - Very-Simple-Logic-Simulator circuits you might miss that above shown wiring with currentsources ("B" and "Ground"-Clamps) having in mind a Circuit with a "+" and a "-" connection like the shown "Battery-Switch-Lamp"-Circuits.
Keep in mind that in all hereafter discussed circuits all Gates and circuits needs a connection to a Voltage/Current-Source.
Because of that fact there is no necessity to explicitly draw them.
Also we will call a "Clamp" being in a "high" State if it's logical Value is "1" otherwise "low" or "0"  independently of how it will be electrically represented by a potential or a current.
High-stated Clamps and Wires are shown in different Colors and Fontstyles.
Here is how
nor - Very-Simple-Logic-Simulator represents above NOR-Gate with high output due to both low inputs:

  inserted with button    from the nor - toolbar

While playing with the examples of that Tutorial have in mind (if its not clear to you yet) that your goal is: "How to construct an universal machine to take logic decisions depending on various inputs and rules".
That might deal with the settings of a lot of electric switches or on some information from equity researchs. Its a matter of naming it.

Example 0:   If you don't have any Idea on handling binary Digits   

Samplefile:   FirstStep.nor

FirstStep  FirstStep.nor

In that Sample you see two of the Tooldevices for generating and visualizing Inputs and Outputs.
The left Source-Element produces Output on its Clamps according to the Value in the Editfields indicated by you.
The upper Input-Field of the Source-Tool-Element contains the Outputvalue in hexadecimal, the lower one in decimal and the four Clamps 'y0'...'y3' in binary
The Seven-Segments-Meter-Tool-Element on the right is connected with the Source via four "Wires" representing a four-Digits binary Number.
(Note: The topmost 'Clamps' labeled 'x0' resp. 'y0' represents the least significant digit of  their values. So reading is always done from top to bottom.)
The Source-Element enables you to generate Input-Values in four ways:
- Focus the upper Inputfield and write in a hexadecimal Value via Keyboard
Focus the lower Inputfield and write in a decimal Value "
- Use the Buttons (belonging to a Scrollbar as you will see later) to adjust an output-Value
- or click with the left Mousebutton on one of the four output-"Clamps" of the Source to switch it on("1") or off("0")
Trying all possible Settings you will get the following Results:


As you see with the ten Symbols from the decimal Notation you can count from 0 to 9. (Please keep in mind that every Counting starts with "0" not with "1".)
If you want to count further on you will begin again with "0" and indicate that fact in writing a "1" one digit left to get 10. So with the ten different Symbols in the decimal System you can count from 0 through 9 on one digit. Then you need a new digit whose value is ten times the first one due to your ten available Symbols.
Now try to count with only two instead of ten Symbols.
You count: 0, 1, now your Set of Symbols is at its End similar to the Situation counting until 9 with a decimal Symbolset. So you react in the same way as mentioned above, beginning again with 0 and adding a "1" at the next digit left resulting in "10". To count one more time you again use the right digit resulting in "11".
Because you only have two Symbols you earlier need a new digit in comparison with the ten-Symbols(decimal)-System. Also each new digit in that binary-System has an only two-times (instead of ten-Times) Value of its antecessor.
The binary System is used in computing Machines because it is much easier to represent only two different Values than ten. On the other Hand you need more digits to describe the same Value.
Keep in mind: To represent a given Number you can use an arbitrary Set of Symbols for Example ten or only two. Each time you used all Symbols there is the need to begin with the first Symbol (the null-Symbol) on the same digit and to use a new digit which is <amount of symbols> ^ <place of the digit> times stronger than its antecessor.
For Example the "1" in the decimal Number 10 has the value 10^1 = 10 (digits are numbered from the right to the left beginning with 0 at the rightmost digit).
Analogues the "1" in the binary Number 10 has the (decimal) value 2^1 = 2.

Last, what about the middle column in the above table titled "hexadecimal"?
As you mentioned from the above you need four binary digits to count up to decimal 15 but need two digits in case of decimal numbers. Because the first basis on multiples of 2 and the second on multiples of 10 there is no simple way to fast compare binary and decimal numbers on a glance if you do not want the necessity of a lot of digits. So you will probably use another numbering-System to express the binary values also basing on multiples of 2. The usual way is a numbering-System based on a multiple of 2 namely 16, what is called a hexadecimal(16) System.
Dont worry its much easier than you think. For Simplicity we use the Symbols "0" to "9" from the decimal-System and add 6 more Symbols taking the first 6 Symbols from another well-known Symbol-Set, the Alphabet. Now we are able to count from 0 to 15 (decimal) or from 0 to 1111 (binary) or from 0 to F (hexadecimal) with the need of only one digit in the hexadecimal case.
Keep in mind: we were dealing with the question of how to represent numbers with different Symbol-Sets which has no influence on how to calculate with them.

To distinguish between the several Notations you will often find additional Symbols like a "d" for decimal, a "h" for hexadecimals or a "b" for binary Numbers or something else. d, h and b are used in the current Application.

Use the Example-Circuit to make yourself familiar with that different Symbol-Sets because otherwise there is no chance to understand anything in logical Circuits. Mention also that the Question which Symbols you use is arbitrary. The two States of binary digits may be expressed by "0" and "1". But you can also use "off" and "on" or "low" and "high" or "white" and "yellow" (as used by default in our nor-Application) or "false" and "true". The latter gives a hint on why binary numbering-System is very well suitable for expressing logical cohesions.

Example 1:   The five available native logic Elements   

Samplefile:   Logical-Elements.nor

Open the Sample-nor-Descriptionfile "Logical-Elements.nor" from the folder "Samples" whose default Position is "C:\Program Files\ibh\nor\Samples".
That Samplefile shows all five native logical Elements you can use to build any Circuit from.
All that Elements come with two Input- and one Output.-"Clamp".
Get familiar with its different Behaviours in Clicking on its respective Input-Clamps titled "x0" and "x1" and observing the resulting Values on the Output-Clamps titled "y".
Recognize the two Groups "ORs" and "ANDs". "ORs" changes their Output(y) if one of their Inputs(x) is changed. "ANDs"
changes their Output(y) only if both Inputs(x) are changed.
In the Case of "NOR" what means "NOT OR" and "NAND" what means "NOT AND" the Output is simply inverted. Notice that in the case of a "XOR" (exclusive OR) Output is set to "1" if only one of the Inputs is set.

Notice: We discussed to add a "NOT"-Element as a lot of Users will look for it. But in view of Simplicity there is no need for it because you can use either a "NOR"- or a "NAND"-Element to invert a logical Value.
To proof that we introduce "nested" Circuits here. Build your first nested Circuit as follows:

- Get an empty nor-Window by  Menu "File/New" or (if you want to keep the Five-Elements-Example from above) via Menu "Windows/New Window".

- Insert a NOR-Element on the empty Workspace
or via Menu "Element/Ins(ert) Type.../nor". (If you want to erase an Element make it the current one by clicking on it or mark several Elements with the Mouse and use Contextmenu or [Ctrl]+[Del] to delete them.)

- Cause the Circuit shall be used by other Circuits insert an external Input-Clamp with
or Menu "Element/Ins. ext. Input (x)".

- Insert an external Output-Clamp
analogues with or Menu "Element/Ins. ext. Output (y)".

- Connect the external Input-Clamp (x0) with one of the NOR's Inputs (x0 or x1) while pressing the left Mousebutton on that external Input-Clamp and dragging a 'Wire' to the NOR-Element-Input.

Notice: Dragging wires (Connections) can be made only from Output-Clamps to Input-Clamps.
An Output-Clamp can possess arbitrary Connections to Inputs. An Input-Clamp can only have one Connection to an Output.

- Connect the NORS-Output-Clamp (y) in a similar way to the external Output-Clamp (y0).
Notice that the yellow indicated "high" Value of the NOR's Output (y) is propagated to the now connected external Output-Clamp (y0) rightmost.

- Save your first Circuit in a File "testNOT" on Harddisk with Menu "File/Save". Ready.

Your Circuit should look like that:

testNOT  testNOT

Try your Circuit in Clicking on the external Input-Clamp (x0) leftmost on your Workspace which leads to a "high" (yellow) State at that Clamp and the connected Input-Clamp at the NOR-Element as well as to a "low" (white) state at the Output-Clamps and vice versa.

Now use your Circuit in another Circuit:

- Again get an empty Workspace as described above.

- Insert a Clone of your just created Circuit with
or Menu "Element/Load Element..." and load File "testNOT.nor".

The result should be as follows:

testNOT1  Usage of testNOT

Verify the Bahaviour of that new Element as that of a NOT-Element by Clicking on its Input-Clamp (x0).
If you list the Results in a Table with one Column for the Inputvalues and one for the Output it might look like that:


Such a Notation is often called a Status- or Truth-Table and is used to describe the Behaviour of a logic Element.

Notice: Use the build-in Function "Statustable" to get Statustables of native or static, self made Elements automatically via Menu "File/Statustable" or [F3] for the whole Circuit (with both external Input- and Outputclamps) or with "Elements-Context-Menu/Statustable" (right mousecklick or [Ctrl]+[F3]) for the current (clicked) Element.

Notice: To see the Circuit of a nested Element doubleclick on it or make it current and use "Open" in its Contextmenu.

Following Table lists the available native Elements in nor - Very-Simple-Logic-Simulator with their Functions:

(Insert with Button    resp. it's Listbutton from the nor - Toolbar or change behaviour with the element's Contextmenu.)

nor NOR Inverted OR, inverted Disjunction, >=1 NORst
Inverted AND, inverted Conjunction, & NANDst
Disjunction, >=1 ORst
Conjunction, & ANDst
Exclusive OR, Antivalence, =1 XORst

Example 2:   Another Circuit   

Samplefile:   AND2+1.nor

Improve your Abilities in constructing Circuits with the following Example where we assume that there is a need for an AND-Module with three Inputs, one of them with inverting Character.

AND2+1  AND2+1.nor

Open the File "AND2+1.nor" from the Samplesfolder.
(Notice: If you have difficulties
to understand its Functionality first have a look on AND3.nor which is a simple AND-Module with three Inputs.)
As you may derive from its Statustable ([F3] or Menu "File/Statustable") or by manually switch the Input-Clamps with Mouseclicks, there is only one Input-Combination (binary: 011, decimal: 3) that causes a high Output.


Notice: To change the external Clamps' Labels (for Example to indicate the inverting Input x2 with '°' as in the Sample), click with the right mousebutton on ext. Input-Clamps or with a Doubleclick on the ext. Output-Clamps. Then perhaps change the Width of the external Regions with their vertical Splitters.

Finally use that Circuit in another one analogues to Example 1 what may look like the following:

AND2+1-usage               AND2+1-usage-wide

With Menu "View/Wide Clamplabels" or Key [F8] you can enlarge such nested Elements (right image) due to wider Labels.

Example 3:   Getting it all from one   

Samplefiles:   nand_from_nors.nor  and  nor_from_nands.nor

As we mentioned earlier all thinkable logic Circuits can be made from that five Elementtypes described above. This is quite advantageous with a view to Simplicity. But we can get a step further on in Simplifying due to the Fact that all logic Elements can be produced from one Element only if that have an inverting Character!
If you do not believe try Sample-Files "nand_from_nors.nor" and "nor_from_nands.nor", view Statustables and compare them with their native Types.

Notice: You can use the Samplefile Testbench_Compare_NORS.nor to easy compare different static Circuits. Here you will find another nested Circuitry called "Compare8bit.nor" which is build up from 1-bit-Comparers defined in Compare.nor. (Use the Clock's Listbutton to get ongoing Input-Pulses.)

There are often several possibilities to realize a given logical behaviour, among others varying in the number of Gate-Inputs to be driven and the number of necessary State-Changes, having in mind an electrical context.

The nors's Statusbar will announce "Fanout max." and "alternating Outp.".what can be interpreted as follows:
- Fanout max. gives you a hint on how much Inputs have to be provided by a Gate's-Output thus influencing the electrical Lay-out of a real Circuit. For example if you intend to realize your Circuit from an ASIC (Application-specified-integrated-Circuit) it might be advantageous not to have a lot of Gates with low Powerconsumption and only a few one with a high one due to high Fanouts. In that case you will probably spread Outputs by several "Driver"-Gates thus getting Gates with similar electrical Properties.
- Alternating Output shows to you how much Gates change their Stati during last Inputevent. As if changing the Status costs Time due to the necessity of building up and down magnetic Fields (Inductivities) and to move electrical Charges (Capacities) you probably will lay out your Circuit having as less as possible Changes if you want to obtain high Performance (Frequencies).

Example 4:   One-Bit-Adder   

Samplefiles:   ADD_half.nor and ADD.nor

Now we will construct a first calculating Circuit which is able to add two one-digit binary Numbers. That might be quite less. But as you will see later that Circuits can be cascaded to calculate even higher Values.
At first open the nor-Description-File "ADD_half.nor" from the Samples' Folder to learn the Principals.

ADD_half  ADD_half.nor

Here is the Statustable (with [F3]) which you should recognize as 'exclusive-or'-Behaviour:


As you can see from the Statustable the Circuit works fine in the first three cases where the Input (the two Input-bits at external Clamps "a" and "b") is null or only one Input is "1".
In the fourth case - both Inputs are "1" - an Overflow occurs which can not be handled by that Circuit.
Also if there is an Overflow in an eventually preconnected Adder we would not be able to handle it.
Because of that this Circuit is called only a "Half-Adder".
For propper Handling these additional cases we must enhance the circuit as follows.
Consider at first (while using the Statustable) on which condition an overflow occurs. Which Element senses that?

Open File
ADD.nor in another nor-Window (via Menu Windows/New Window) and compare it with "ADD_half.nor". You will see an extension of the Half-Adder to a "Full-Adder", being able to additional calculate a "Carry"-Input from a preconnected Circuit as well as to signal an occurring Overflow to a post-connected Circuit via it's Output "ovfl".
This is our basic adding Circuit which we will now enhance to deal with greater Numbers than One.

Notice: For moving the external In-/Out-Clamps up and down on the Workspace's margins hold down [Ctrl]-Key and drag them with the Mouse.

Example 5:   Two-Bit-Adder   

Samplefile:   ADD2.nor

Now lets proof whether we can add two two-digits-binary Numbers while simply cascading two previously described Full-Adders. Open File "ADD2.nor".

Add2  Add2.nor

Both embedded One-Bit-Full-Adders are enlarged with Key [F8] to show complete Labelcaptions.
The upper one is responsible for adding the both least significant bits ("LSBs", from Input-Clamps a0 and b0) while the second Adder calculates the most significant bits ("MSBs", Inputs a1 and b1).
If there will be an Overflow in the first Adder its Output-Clamp "ovfl" will go high and this will be propagated to the seconds Adder-Input "carry".
Remember our Example 0 where you learned that you can count up to three with a two-digits-binary Number. Let us extend the Circuit so we can add two real Bytes each consisting of 8 bits to allow an eight-bit-Result or in decimal notation 255.

Notice: You may use the Statustable-Function [F3] to view the Behaviour of that Circuit. Try to Sort the Table on different Columns by Clicking on their Titlecaptions or to put it into Windows' Clipboard via it's Context-Menu for further use in ie. a Textdocument. (If you need a Bitmap of the Circuit use Menu File/Print or [Ctrl]-[P] to copy one into the Clipboard.)
You may search for associated themes with Google.

Example 6:   Eight-Bit-Adder   

Samplefile:   ADD8.nor

Open File  "ADD8.nor" and use Function "Fileinfo" available from Menu "File/Fileinfo" or Key [F9] to comprehend the nested Circuits.

Add8-Fileinfo  Add8-Fileinfo

The Fileinfo-Window is giving an Overview about the Context of the nested Circuitry. In our Example Add8.nor you can see in the upper third of the Window that it consists of two four-bit-Adders out of "Add4.nor" which for their part are each consisting of two two-bit-Adders as described in the previous Examples each containing two Full-Adders.
(Notice: If you are dealing with HDLs [Hardware-Description-Languages] such as VHDL compare the Sections "Clamping" [connections of In- and Outputs] and "Elements" [what is connected] with the therein used Notations.)
In the middle Section beneath several Projectinformations you'll find that it needs 24 NORs, 16 ORs and 16 ANDs to receive a calculating Machine able to add two 8-bit-Numbers (decimal 0...255).

Now use your new 8-bit-Adder to construct a simple Calculator as you'll find in Calculator.nor :

Calculator  Calculator.nor

Do not be to much impressed by the apparent complexity of the wiring. After a while you see that the Heart of that Circuit is only the known 8-bit-Adder whose two 8-bit-Inputs are simply driven by two "Source"-Tool-Elements from the "Ins."-Element-List on the Toolbar or the Menu you became already acquainted with in Example 0, thus giving the Opportunity to input Decimals as well.
On the right Hand of the 8-bit-Adder there are some "Meter"- respectively "7-Segment"-Tool-Elements for displaying the Result in all three earlier discussed manners (decimal, binary and hexadecimal). Try also the Function of the One-bit-"Meter"-Element
with it's "LED" beneath the Results-Display.

Now at first enjoy the Fact that you build up a Circuit being able to Calculate for itself without using the Processors own calculating capabilities as it is usually done, even the Result is restricted to 8-bit Numbers. If this is too less for you extend it like in Samplefile "Calculator16.nor" . . .

By the way: We assume that you already discovered the additional Elements in the "Ins."-Elements-List come along with the Toolbars
-List-Button or the Menu "Element/Ins. Type..."-List. In its second Section you'll find some useful Tool-Elements for simplifying  Input/Output-, Display- and Storing-Tasks.
Some of them let you adjust their bit-Widths with an Up/Down-Button in its right-upper-Corner. UpDown-digits-Button
With regard to the 7-Segments-Elements at the same place there is a Switch labeled "d" to add a Decoder for directly convert 4-bit Values (decimal 0...15, hexadecimal 0...F) into hexadecimal digits.
Nevertheless you could also construct your own Decoder from the native logic Elements. So this is for faster Working only.

A hint for Teachers: To consolidate the understanding of the several ways to represent Numbers you may perhaps let your Students add another One-Bit-Meter-Tool-Element with its "LED" to indicate if the current Calculator-Result is odd.

Example 7:   Flipflop, one bit of Memory   

Samplefile:   FlipFlop.nor

Now its time for something new. All our present Circuits are static and all bit-Stati are volatile. If you switch a high-leveled Clamp, representing a "1" it will at once change to "0" and nothing in the Circuit will remember its previous State. Consider a simple Task like Counting Events. Up till now we do not have a Solution.
In other Words: How can a Circuit memorize a former State?
Here it comes:
Open the Samplefile with the funny Name "FlipFlop.nor" from the Samplesfilefolder consisting of only two NORs.

FlipFlop  FlipFlop.nor

At first try the known Function "Statustable" with [F3]. The surprising Result is a Message that a static Truthtable can't be displayed because there is no clear Cohesion between Input and Output.
So let us try manually what happens.
Set the Input-Clamp "x0" from low to to high-Level ("1") thus forcing the upper NOR's x0-Clamp getting high too.
Because of its high Input this inverting Element will set its Output "low" ("0").
This Output is connected to an Input of the other (lower) NOR, thus setting its Output consistently to "high" (1), forcing the second Input of the upper NOR to become "high" too.
At that point be attentive what happens now if you reject your "high"-Signal from the external "x0"-Clamp you have set at first:
Notice that all bit-States keep as just described despite the Fact you switched off the Input!
Remind yourself our Goal to memorize bit-States. You just meet it.
Your Circuit obviously 'remembers' that you fired the external Input-Clamp a time ago and due to its self-locking-mechanism it 'holds' that Status even if you change the Input. The self-locking replaces the lacking former Input that might be on only for a short timeperiod.
The Output will remain "high" ("1") until a complementary Input is set via the other Input-Clamp here labeled "reset".

Now we are in the State to calculate and to memorize using only native logic Elements which - as mentioned earlier - could also be replaced by one of the both inverting Elementtypes NOR or NAND!

Notice: See also Samplefile Test-psc-spc.nor with parallel-to-serial and serial-to-parallel-Tranformation where our FlipFlop-circuit is used inside the serial-to-parallel-Converter.

Let's enhance our Circuit now for Counting.

Example 8:  

Samplefile:   1bitCounter.nor

In that Example we will introduce the Tool-Element "Clamp" whose only Task is to make complex wiring more clear as you'll see in this Samplefile.
Clamps can be represented in two manners to use them in different Context. Switch between them with [F7]-Key or via their Contextmenu.

1bitCounter  1bitCounter.nor

Expense some time to analyze that Circuit because its basic for any counting-Problem.
You see two Flipflops memorizing alternately the otherones's State.
The rest of the Circuitry serves for it's ability to be resetted to a known State what isn't defined from itself unlike in all previously discussed Circuits.

Notice: For that purpose you'll find an external Input-Clamp labeled "reset".
Each time you open a file with Clamps you labeled "reset" (by right-clicking on the ext. Inputclamp) that Clamps will shortly set to "high" ("1") during loading to force the Circuit to go into a defined State.
That functionality must be implemented by yourself like it is in "1bitCounter.nor"!

Now try that Circuit in firing the external "x0"-Clamp (click on it). What happens?
Each time Input goes "low" ("0") the ext. Output ("y0") rises to "high" ("1"). So you need two Clicks onto the ext. Inputclamp to get one Change at the Output.
In other Words: If your Output changes one time you know that there has been two Input-Events since the last Outputchange.
That Circuit obviously counts to One what again isn't very much but think of cascading . . .
There are several counting-circuit variations. You may search for associated themes with Google.

Example 9:   Eight-Bit-Counter   

Samplefile:   8bitCounter_Meter.nor

The following Example shows cascaded 1-bit-Counters (the previous Circuit "1bitCounter.nor") together with some Displays for studying purposes (only).

nor - Very-Simple-Logic-Simulator, Logik-Simulator, Schaltung, Unterricht, Schule, Informatik, Lehrmittel, School, Education, Training, Download 

Try a Doubleclick on one of the 1-bit-Counters or open its underlying Circuit via Contextmenu ([Shift]-[F10] if current or Mouse-right-click) to verify it's Content.

Repeatedly click on the external Input-Clamp "x0" on the left to generate Input-Pulses and watch the State of the several Countermodules. Each Counter divides your Clicking-Frequency by two and passes it on to the next one.
View how the Outputdigits are 'filled up' from LSB (upper) to MSB (lower).
The parallel switched Meter and 7-Segments-Display shows the corresponding decimal respectively hexadecimal Values. If you intend to use that Circuit in other Circuits don't worry about the additional Displayelements, because in that case they will simply be ignored and so do not disturb.

Notice: If you get bored in clicking on the Input-Clamp let the Application doing that for you.
Open the "Clock"-Buttons-List Clock-Button in the Toolbar (or from Menu "Element/Clock-Events...") and choose one of the offered Clock-Speeds. You will then asked what external Input-Value should be used by the Clock-Timer (if that isn't defined yet). As the ext. Input-Clamp you need is the LSB (least significant bit) answer with "1". That Value as well as an "Idle-Input-Value" and 10 further predefinable ext. Input-Values obtainable by Keys [0] through [9] are stored in the nor-Descriptionfiles.
After doing that the ext. Inputclamps will repeatedly changing between "0" and "1" until you click on the "Clock"-Button or press Key [F4]. Restart it with another Click on the "Clock"-Button or [F4].

Perhaps you now might have a Hardcopy/Printout of your Circuit.
Use the appropriate Function from the "File"-Menu or press [Ctrl]+[P].
The resulting Preview can be printed or stored into the MSWindows'-Clipboard for use in other Applications.

A little hint for Teachers: This is the fastest way to get Lesson-Worksheets.
Perhaps you remove some Wires/Connections in your Circuit and let your Students fill it in to proof their Understanding. An example could be the
self-locking connections in a simple Flipflop-Circuit. Recognizing that Lack verifies explicitly the Understanding.
For Testing a given Connection click on an Input-Clamp with right Mouse-Button. This will temporarily disconnect that Wire. Another Right-Click on the same Clamp restores the former Connection. That procedure may also be helpful to clear up the individual function of each connection.

Example 10:   RAM and Shiftregister, LED-Display   

Samplefile:   Display.nor

This Step is to learn about two different Storing-Units, the Memory with random Access (RAM) and the serial Memory with either "Last-In-First-Out" (LIFO) or "First-In-First-Out" (FIFO) behaviour. Both here offered Tool-Elements "RAM 256x8" and "Shift-Register" bring with them the ability to display their Contents.
Also you might get a first Idea on a 'programmable Machine' which could lead to an Understanding of what a 'Processor' is doing.

For a first Glance get a blank Workspace and insert a "RAM 256x8"-Element.
Then widen it's built-in Display
to at least eight or more 'Bytes' by using the Up-/Down-Button on it's upper/left Edge. You should receive an image as follows:


There are three Clamp-Sections on that Tool-Element:
- Clamps x0...x7:  These Clamps must be set to the Value to memorize
- Clamps a0...a7:  These Clamps must contain the 'Address' into which memorizing shall be done
- Clamps y0...y7:  These Clamps will contain the Memories Output

Probably you now just know what to do. So lets attempt to store a Value into our RAM what can hold ('address') 256 (2^8) different memory-places each of 8 bit wideness.

- At first set the Value-Input-Clamps (x0 through x7) to a Test-Value. We use the decimal Value 170 that is in binary digits the nice Pattern 10101010 and in hexadecimal Notation AA. So you click on x1, x3, x5 and x7 to set them "high".

- Then choose an Address where that Value should be stored. You have 256 Possibilities what means an Addressspace between 0 through 255. As we just display only the first 8 Addresses simply let the memory-Address keep on "0". (Otherwise use the Memory's Scrollbar if necessary.)

- Now trigger the memorizing-Process by firing the "clk"-
(Clock)-Clamp at the lower/left Edge with a Mouseclick.

The Result should be the following:


Just try another Address lets say 4 (what means that you set Address-Clamp "a2" alone to "1"), leaving the Testvalue on AA and reset and again set the "clk"-Clamp with that Result:


As you see, the "RAM 256x8"-Element displays it's Content in that case like a Logic-Analyzer.
You can change the View by using the small Button RAM-Style-Button on the right to alternative Displaytypes for Example into an LED-Rows-like one.

This was Writing into the Memory. Now we finally need a Method to Read from it. Here it is:

- Reset the "clk"-Clamp to "low" ("0") by again clicking on it.

- Assume you need the Value stored at Address 4, so leave the Address-Clamps unchanged.

- Fire the "r/w"-(read/write)-Clamp by Clicking on it to switch the Memory from 'Writing' to 'Reading'.

- Click on the "clk"-Clamp what - due to the high-setted "r/w"-Clamp - induces the RAM-Element to output (instead of storing) the Value (170d[ecimal] or AAh[exadecimal] or 10101010b[inary]) stored at the current Address (4d or 4h or 100b).


The Buttons labeled "St" and "Ld" on the RAM-Element enables you to store (St) or to load (Ld) the RAM's Content into/from a Text-File in
hexadecimal Notation thus using it as a Data-Recorder.

This is done in our Example "Display.nor" to get Character-Patterns from (in the Case of that Sample) a File "Characters.txt" which can be viewed and edited with any ASCII-Texteditor like Windows' Notepad.
Additionally you can edit the RAM's-Content by simply doubleclicking on a bit-Memory-Place what is currently shown on it's Display. A right-Click on the Display will show the corresponding Byte-Value. The both small Bars indicate current Writing-(blue) respectively Reading-(green)-Address.

A nice Sample for becoming familiar with the RAM-Element is Random.nor which generates random Patterns in the RAM's Display.

It shouldn't be difficult for you now to understand the other available Type of Memory-Element called "Shift-Register".
Add one on your current Workspace for similar Testing and enlarge it too with its Button on the upper/left Edge.

The main difference to the RAM is the lack of Addressability. All incoming Values are stored 'as they come' either in forward Direction (first-in-first-out, 'fifo') or in reverse Direction (last-in-first-out, 'lifo') depending on the Status of the "c/d"-(clear/direction)-Clamp. Setting
the "c/d"-Clamp reverses the Storing-Direction (at the bottom or at the top of the Memoryspace) and clears the Memory what can also be done with the "C"-labeled-Button.

Hint for Teachers: It might be a useful discourse to speak about 'Clearing' a Random-Access-Memory which is obviously a matter of how the Status 'cleared' will be defined in opposite to a Shift-Register which will be actual empty after clearing.

Reading from the Shift-Register:
As soon as the Memory-Content reaches the right side of it's Display (and therefore the Memories end) the next Storing-Operation will cause two things:
- The Value at the Input-Clamps is stored as mentioned above and
- the last Value (at the End of the Content) will be applied to the Output and rejected
unless the 'additional Memoryspace'-Checkbox Shift-Reg-AddMem is set.
If that Checkbox is set, Memory will only be limited by the Computers Memory otherwise by the current Length of the Display adjusted by you.

With a Shift-Register-Element you can also store Values that are wider than 8 bits.
Adjust that with the Up/Down-Button at the upper/right Edge.
The maximum Display-Width is 64 (for RAM and Shift-Register), the maximum digitscount for a Shift-Register is 32. So with a Shift-Register you can store for Example four 8-bit-Values at the same Time. That is the Reason for the kind of Storage in the Textfiles in hexadecimal Values.

Now its time to look at our Samplefile "Display.nor":

Display  Display.nor

First, lean back and slowly analyze our apparent most complex Circuit in that small Tutorial.
It essentially consists of two Shift-Registers, one to store the Text that should be displayed, the other to show that programmable Text like a LED-Display, and a RAM to hold the Character's Patterns.

In the centerregion you see a 3-bit-Source, a 3-bit-Counter and a 3-bit-Comparer (doubleclick to see their underlying Circuits) which gives an Event at it's Output-Clamp "c0" each time the Counter equals the Value of the Source here 7. That Output is used to shift the lower/left Shift-Register via it's "clk"-(Clock)-Clamp to the next Characternumber giving the upper five bits for the RAM's Address-Inputs.

The lower three Address-bits are added from the 3-bit-Counter to scan the selected Character thus generating the Input-Signals for the displaying, upper Shift-Register.
The high lower 1-bit-Source (Current Source-Elements' Output-Values are stored within the nor-Descriptionfiles) drives the r/w-(Read/Write)-Clamps to "Read"-State.

The other Elements are serving the "Programming-Modus". So if you want to alter the displayed Text firstly shut off the Clock by [F4], then set the Text-Memory to "Write"-State via the upper Single-Clamp (#52) beneath the 5-bit-Source on the left. Set the appropriate Value of the desired Character. With the second Single-Clamp (#92) trigger the "clk"-Clamp so that your Character's Number is stored in the Shift-Register. Finally set both Single-Clamps to "low" and restart the Clock-Signal to display your new Text.

Hint for Teachers: Themes for discourses might be the following questions:
- What must be changed to get other Characters?
-  "  to get wider/smaller Characters?

Example 11:   Controlling external Hardware via the Parallelport   

Samplefile:   PIO.nor

With the both Tool-Elements "Par. Input" and "Par. Output" you can read and write from/to the Standard-Lineprinter-Port (LPT1:) of your Computer. This works under Windows-95/98 as well as under Windows-XP and is based on the DLL IO.dll by Fred Bulback. The documentation for IO.dll can be found at  http://www.geekhideout.com/iodll.shtml.  The accompanied DLL IO.dll is not an integral Part of that Application - you can run nor without IO.dll - and thus free of charge!
Use "Par. Input"- and "Par. Output"-Elements for the most simplest way to control external Testhardware i.e. to directly switch some connected LEDs.

Warning: Connecting unsuitable Hardware others than commercial Printers to the parallel Port of your Computer can cause serious Damage of the internal or external IO-Devices and thus requires full knowledge about the electrical Context!  You will do so always on your own risk. Visit Fred Bulback's Site to get further Information.

(Notice: nor-Very-Simple-Logic-Simulator proofs only once, at it's first start, whether IO.dll can be processed properly. If that is not possible due to Machine- or System-Properties, nor will store that fact in it's Configurationfile nor.ini which you will find in the Applicationsfolder (that is by Default: C:\Program Files\ibh\nor) and will not perform any further attempts to access the Parallel-Port.
If you want to access the Parallel-Port yet in that case (only), you must change the Value of the Entry "wio" to "1" in nor.ini. Otherwise IO isn't accessible. In the opposite case, if you explicitly want to suppress IO-Access via IO.dll (which is working as kernel mode driver) set that Value to "-1".)

"PIO.nor" shows how to read and write to the Lineprinter's Port i.e. by generating Output-Data via a Shift-Register-Element (in the Sample the Characters ABC and a 'Pagefeed'-Command (12d) will be send to the Printerport).
Data is sent respectively updated each time the "clk"-Clamp is set "high".

Have a lot of fun.

» home

©2008 Ing-Büro Bechler Halle

home  |  nor-Tutorial  |  nor-Forum  |  nor-Lizenz  |  nor-Download  |  plan  |  IT-Training  |  Software-Entwicklung (Engl.)