• Home
• projects
  • APK on Android
  • K-Cookies
  • deprecated
    • Assembly from Scratch
    • GladeExamples
    • Internal Debugger
    • Learner Kernel
    • Rock Race
    • linhead
• tutorials
  • IRC
  • Japanese
    • Accenting
    • hiragana
  • WIP
    • From Atoms to Coding
      • 0 Introduction
      • 1 - Chemistry And Electricity
        • 01 - Direct Current
        • 02 - Least Resistance
        • 03 - Diodes
        • 04 - Transistors
        • 05 - AND Gates
        • 06 - AND Abstraction
      • 2 - Logic And Numbers
        • 07 - Basic Logic
        • 08 - Hex-Decimal
        • 09 - Binary
        • 10 - Simplest Adder
        • 11 - Full Adder
      • 3 - CPU Components
        • 12 - MUX and DEMUX
        • 13 - RS Latch
        • 14 - Basic CPU
        • 15 - Memory
        • 16 - BUS
        • 17 - Clock
        • 18 - External Hardware
      • 4 - Software Theory
        • 19 - IRQs
        • 20 - Sample of MCU Assembly
        • 21 - Operating Systems
      • 5 - The Tools of the Trade
        • 22 - Disk Operating System
        • 23 - VIM
        • 24 - The GNU Compiler Collection
        • 25 - MAKE
      • 6 - First Steps in Coding
        • 26 - Hello in Assember
        • 27 - Hello in Bootloader
        • 28 - Hello DOS Assembly
        • 29 - Near Universal Makefile
        • 30 - Actually Doing Something in Assemby
        • 31 - Hello in C++
        • 32 - C++ Operators
        • 33 - Using printf()
        • 34 - Control Flow
        • 35 - Function Templates
        • 36 - Function Overloading
        • 37 - Arrays
        • 38 - Unions
      • 7 - Game to Learn the Rest
        • 39 - Getting Started with VGA
        • 40 - Classes for Stars
        • 41 - Setting Up for the Future
        • 42 - Really Getting Ahead
        • 43 - Border Collision
        • 44 - Object Collision
        • 45 - Sprites
      • Special Topics
        • How to Find the Fastest Programming Language
        • Important: Programmer Depression
        • Why Compilers Suck at Optimizing
• about
• Website Services
  • Backup IRC Client
  • IRC Chatlogs
  • Image Hosting
  • Email

This page was last updated on March 13th, 2020(UTC) and it is currently May 30th, 2023(UTC).
That means this page is 3 years, 78 days, 8 hours, 50 minutes and 52 seconds old. Please keep that in mind.

Before we investigate the multiplexer, let us first analyze a simple "decoder." If you imagine this component with 8 inputs, you could easily imagine it then having 256 outputs, which is a lot of transistors and lights just to put a number on the screen. Even worse if it were to be 16 inputs (65536 outputs). The bad news is, such things exist. The good news is, you only have to understand this simple one and figure out how you could expand it.



Now, rather than going into all the possible circuits that we can use for operations (especially as that number inreases), it is simpler to have you look up the ones you're actually interested in. Just a hint, though, multiplication and division are usually "looped," meaning they feed their output back into themselves and they use a "clock" to help them limit the number of times this happens. Since you don't understand what that means, let's just say that you probably don't want to look it up at the moment. "Dividers" as you'll most likely find are a whole other type of circuit (clock dividers and such) that serve a totally different function that you are imagining.

So, the simplest way to improve upon the machine I had you visualize thus far is to make it so it can do more than simply addition. However, to "switch" operations and use only one output display, you need a way to connect the output to the operation in such a way that only one of them gets to the screen. In your head, you're probably imagining alot of AND gates. You would be right, but there's a much easier way to visualize this.



This is just a simple sample. You take the decoder from the previous lesson, tie it to some and gates, and you can easily imagine a box that allows us to do what we want without actually having to visualize all the AND gates. Notice the OR gate at the end takes in 4 inputs. It's basically a bunch of OR gates in series that filter their inputs into a single output. It works exactly as you would predict it to.

And that diagram above is for only 1 bit of output for an 8bit computer with 4 operations. A more realistic computer would be over 100 operations at 32bits or 64bits. The people who spent their lives making room sized computers just to fit all the vacume tubes (pre-diode diodes) and wires together were made fun of, for they dedicated an entire room or more just to have a calculator. Now, keep in mind that a good portion of those same people later became among the (as of writing this) 57,613,844 views of this incredibly famous video, which probably has gotten more attention than the people who made the video possible. The most ironic part? I really don't think that cat cares.

The especially good news about all of this is that there is shorthand for making 1 wire represent, say, 8 bits. That doesn't mean that there are actually fewer wires, but it does mean that it's easier on the eyes.



Now, I am somewhat lazy, otherwise I'd horribly draw you a demultiplexer as well. You should be able to imagine it (the single output of multiplexer as one input to a series of AND gates, selected by a decoder circuit). This allows us to have an "omnibus," or "bus" for short. The idea, then is that you can have a series of things connected together over a smaller number of wires (much like a bunch of people sitting in the vehicle referred to as a "bus"). It's the combination of both that allows us to send data from a bunch of wires through a smalle number of wires, back to a larger number of wires. Since the S-pins (wires marked S for Selection) don't have to be of the same size on both ends, this also allows us to take input and shove it into a larger number of outputs, or take a larger number of inputs and shove it into a smaller amount of outputs. There's one small problem, though: only one thing can be selected at a time. So, you can't use this to get away with trying to, say, speed up your internet connection or something. Now, a nifty little thing you can do is make a grid of switches and use this and some OR gates (to keep power going) to make a basic keyboard out of switches instead of buttons. The reason you'd have to do this, is because you still don't know how to "store" the output of a calculation. So, to make a proper keyboard (as well as a bunch of other things), you'll learn about that next.

Get your own web kitty here!
©Copyright 2010-2023. All rights reserved.