Understanding Number Systems: Decimal, Binary, and Hexadecimal

Nice to meet you again! While you are likely accustomed to working with everyday decimal numbers, digital systems rely heavily on Binary (0s and 1s) and Hexadecimal systems. This is primarily due to their convenience and efficiency in hardware design and programming.

Let's break down how these systems work and how to seamlessly convert between them.

1. Decimal Digits (Base 10)

The decimal system uses ten digits: 0, 1, 2, 3, 4, 5, 6, 7, 8, and 9.

Each column represents a value that is 10 times more than the previous column (reading from right to left). These are also called Base 10 numbers because we represent each column as a multiple of a power of 10.

• Capacity: An N-digit decimal number can represent up to 10ᴺ possibilities.

• Example: A 3-digit number has 10³ = 1000 possibilities (ranging from 000 to 999).

2. Binary Numbers (Base 2)

In the binary system, "bits" represent only one of two values: 0 or 1. Each column carries twice the weight of the previous column, making this a Base 2 system.

The Powers of 2 Table

If you work in programming or IT, you will save significant time by memorizing the powers of 2 up to 2¹⁶:

Converting Binary to Decimal: Let's convert 1101 (binary) to decimal: = (1 * 2³) + (1 * 2²) + (0 * 2¹) + (1 * 2⁰) = 8 + 4 + 0 + 1 = 13 (decimal)

3. Hexadecimal Numbers (Base 16)

Binary numbers can become very long and prone to errors when written out. To simplify this, we use Hexadecimal (Base 16).

A group of 4 bits gives us 16 possibilities (2⁴ = 16). With just one hexadecimal digit, we can represent an entire 4-bit sequence!

Hexadecimal Conversion Table

4. Practical Conversions

Here is how you can practically convert numbers between these three systems.

A. Hexadecimal to Binary and Decimal

Goal: Convert 2ED (hex) to binary and decimal.

• Hex to Binary: Map each character using the table above.

  • 2 = 0010

  • E = 1110

  • D = 1101

  • Result: 001011101101 (binary)

• Hex to Decimal: Multiply by powers of 16.

  • = (2 * 16²) + (14 * 16¹) + (13 * 16⁰)

  • = 512 + 224 + 13

  • Result: 749 (decimal)

B. Binary to Hexadecimal

Goal: Convert 1111010 (binary) to hexadecimal.

1. Group into 4 bits: Start from the right. Pad with leading zeros if necessary: 0111 and 1010.

2. Map to Hex: * 1010 = A

   • 0111 = 7

3. Result: 7A (hex)

C. Decimal to Hexadecimal and Binary

Goal: Convert 333 (decimal) to hexadecimal and binary.

There are two primary methods for doing this: the Subtraction Method and the Repeated Division Method.

Method 1: The Subtraction Method (Descending Powers)

You subtract the largest possible power of the target base until you reach zero.

• Decimal to Hexadecimal:

  1. The largest power of 16 less than 333 is 256 (which is 16²).

  2. 256 goes into 333 once (1 * 256). Remainder: 333 - 256 = 77.

  3. 16 goes into 77 four times (4 * 16 = 64). Remainder: 77 - 64 = 13.

  4. 13 in decimal is D in hex.

  5. Hex Result: 14D (hex)

• Decimal to Binary:

  1. 333 - 256 (which is 2⁸) = 77

  2. 77 - 64 (which is 2⁶) = 13

  3. 13 - 8 (which is 2³) = 5

  4. 5 - 4 (which is 2²) = 1

  5. 1 - 1 (which is 2⁰) = 0

  • Since binary digits exist at the positions for 2⁸, 2⁶, 2³, 2², and 2⁰, we place a 1 in those columns and a 0 everywhere else.

  • Binary Result: 101001101

Method 2: Repeated Division (The Remainder Method)

This is often the easiest method for programming or working with large numbers. You repeatedly divide the decimal number by the target base (2 or 16) and record the remainders. Read the remainders from bottom to top to get your answer.

• Decimal to Hexadecimal (Divide by 16):

  1. 333 ÷ 16 = 20, remainder 13 (which is Hex D)

  2. 20 ÷ 16 = 1, remainder 4 (which is Hex 4)

  3. 1 ÷ 16 = 0, remainder 1 (which is Hex 1)

  • Read bottom to top Result: 14D (hex)

• Decimal to Binary (Divide by 2):

  1. 333 ÷ 2 = 166, remainder 1

  2. 166 ÷ 2 = 83, remainder 0

  3. 83 ÷ 2 = 41, remainder 1

  4. 41 ÷ 2 = 20, remainder 1

  5. 20 ÷ 2 = 10, remainder 0

  6. 10 ÷ 2 = 5, remainder 0

  7. 5 ÷ 2 = 2, remainder 1

  8. 2 ÷ 2 = 1, remainder 0

  9. 1 ÷ 2 = 0, remainder 1

  • Read bottom to top Result: 101001101 (binary)

Understanding Digital Abstraction

In the physical world, the information surrounding us is continuous. Think of the voltage running through a wire, the precise position of an object in space, or the frequency of a sound wave. These values can take on an infinite number of variations.

However, digital systems operate differently. They represent information using a finite set of variables, a concept known as discrete information.

From Gears to Bits: The History of Discrete Values

One of the earliest examples of a discrete value system was the Analytical Engine, designed by Charles Babbage. Unlike modern computers, it didn't use electricity; it used mechanical gears.

• The Decimal Approach: Each gear could represent 10 distinct values (0–9).

• Precision: With 25 gears, the machine could perform calculations with 25-digit precision.

• The Trade-off: While revolutionary, it was massive, mechanical, and slow.

You can explore the mechanics further on Wikipedia.

The Binary Advantage

Today’s electronic systems have moved away from Babbage’s 10-state system in favor of the binary system. This system relies on only two states:

• High Voltage: Represented as 1

• Low Voltage: Represented as 0

Why only two? It is significantly easier and more reliable for hardware to distinguish between "on" and "off" than it is to precisely measure ten different levels of voltage. This makes modern computers incredibly fast and resistant to errors.

Measuring Information: The Bit

The amount of information \(D\) in a discrete variable with \(N\) distinct states is measured in bits (binary digits). We calculate this using the following formula:

$$D = \log_2(N)$$

Example 1: A Binary Variable

For a single binary variable (0 or 1), there are \(N = 2\) states. $$D = \log_2(2) = 1 \text{ bit}$$

Example 2: Babbage’s Gears

One gear in the Analytical Engine had \(N = 10\) states (0-9). $$D = \log_2(10) \approx 3.32 \text{ bits}$$ This means one of Babbage's gears held roughly 3.3 times more information than a single modern bit.

Continuous vs. Discrete

In theory, a continuous variable has infinite states, meaning it could store an infinite amount of data. However, due to physical noise and technical limitations, we can usually only measure continuous signals up to a resolution of 10 or 12 bits (roughly 1,024 to 4,096 distinct states).

What is Digital Abstraction?

Digital Abstraction is a "contract" between the physical hardware and the logical designer. It allows us to ignore the messy physics of electrons, gears, or fluid levels. As long as the system recognizes a "High" or "Low" state, we can treat the information as pure logic.

In this series, we will focus on Boolean Logic:

• 1: High / True

• 0: Low / False

By using this abstraction, a programmer doesn't need to care how the 1s and 0s are physically stored—only that they exist. (Though, understanding the underlying architecture certainly helps when it comes to optimizing code!)

Next Lesson: Number Systems

FPGA Engineering Blog Series: Welcome

Hello, my name is Ramiz Qurbanli. Welcome to my new blog series on FPGA Engineering. This series is designed to take you from the absolute basics of digital logic to designing custom chips using the hardware description language, Verilog.

Our Mission: Sovereignty Through Science

The purpose of this blog is to direct Muslim youth toward the sciences—specifically the field of chip design. Mastering this field will not only make you a high-demand talent in the global market but is also essential for the independence of our nations.

As you may know, a few major companies (mostly based in the US) dominate chip design and manufacturing. Recently, we have seen how geopolitical shifts and trade restrictions can limit a nation’s access to critical technology. I believe we must cultivate our own engineers so that we can eventually design and create our own hardware. That is why I have created this blog: to provide a path from Zero to FPGA Engineer.

Why FPGA?

You might ask, "Is FPGA the same as full chip design?" Technically, no—but it is the essential entry point. To become an FPGA engineer, you must master the core pillars of chip design: Digital Logic, Boolean Algebra, Transistor Physics, Combinational and Sequential Logic, Computer Architecture, and Memory Systems.

Chip design is a massive, multi-disciplinary field. While I won’t be teaching you how to manufacture nanometer-level transistors in a "fab" (fabrication plant), I will focus on the Logic Design and HDL (Hardware Description Language) phase. Companies like Nvidia, Intel, and AMD are often "fabless," meaning they design the logic and document it, then send those designs to specialized factories (like TSMC in Taiwan) to be printed.

HDL is the brain of the chip. By learning it, you gain the power to define exactly how hardware behaves.

What is an FPGA?

FPGA stands for Field Programmable Gate Array. In simple terms, it is a chip containing thousands of logic gates that are not "hard-wired." When we write HDL code and load it onto the FPGA, our code tells the chip which gates to connect and in what order.

Unlike a general-purpose CPU, an FPGA can be customized for a specific task, allowing for incredible speed and ultra-low latency.

Key Applications of FPGA Technology:

• Defense & Aerospace: Radar beamforming, signal jamming, and radiation-hardened satellite processing.

• Telecommunications: 5G/6G base station processing and high-speed network protocols.

• AI & Data Centers: Hardware acceleration for Large Language Models (LLMs) and real-time encryption.

• Finance: High-frequency trading (HFT) platforms where every nanosecond counts.

• Medical: Real-time 3D reconstruction for MRI and CT scans.

• Automotive: ADAS (Advanced Driver Assistance Systems) and LiDAR sensor fusion.

Our Learning Roadmap

We will not start with coding right away. To avoid being a "code monkey" who doesn't understand the underlying physics, we will build a foundation as true engineers.

Phase 1: The Digital Foundation

• Logic Fundamentals: Number systems (Binary, Hex) and Two’s Complement.

• Transistor Basics: How CMOS transistors create physical NOT, AND, and OR gates.

• Boolean Algebra: Simplifying circuits using K-Maps.

• Physical Reality: Studying propagation delays and "glitches" in circuits.

Phase 2: Memory and State Control

• Sequential Logic: Latches vs. Edge-Triggered Flip-Flops.

• Finite State Machines (FSM): Designing Moore and Mealy machines.

• Timing Discipline: Mastering Setup and Hold times to prevent metastability.

• Clock Domains: Managing data movement between different clock speeds.

Phase 3: Hardware Description Languages (HDL)

• RTL Coding: Describing hardware using Verilog/SystemVerilog.

• Parallel Thinking: Shifting from "sequential" software mindsets to "concurrent" hardware logic.

• Verification: Writing Testbenches to catch bugs in simulation before they hit the hardware.

Phase 4: FPGA Architecture & Building Blocks

• Arithmetic Units: Designing high-speed Adders and ALUs.

• The FPGA Core: Exploring LUTs (Look-Up Tables) and Routing Matrices.

• Memory Systems: Interfacing with SRAM, DRAM, and Register Files.

Phase 5: Microarchitecture (Processor Design)

• Instruction Sets: Mapping Assembly (MIPS/ARM) to hardware.

• Pipelining: Building an assembly-line style processor for higher performance.

• Hazard Handling: Solving Data and Branch hazards.

Phase 6: High-Speed System Integration

• Cache Systems: Designing direct-mapped and set-associative caches.

• Virtual Memory: Address translation for OS-level hardware.

• Signal Integrity: Understanding high-speed electrical signals and interference.

See you in the next lesson! Our first deep dive will be: The Digital Abstraction.