🧮 PIC Float Division Calculator

---

📑 Table of Contents

• 📖 Project Overview
• 🏗️ System Architecture
  • 🔧 Hardware Components
  • 🖥️ Component Layout
  • 📷 Hardware Components Gallery
• 🔄 System Operation Flow
  • 📱 User Interface Flow
  • 🤝 Master-Slave Communication Protocol
• 💻 Software Architecture
  • 🎛️ Master CPU Functions
  • ⚙️ Slave CPU Functions
  • 🔬 Detailed Division Mechanism
• 🛠️ Development Environment
• 🎮 Usage Instructions
• 🎬 Demonstration
• 📁 Project Structure
• 🔬 Technical Specifications
• 👥 Contributors
• 📜 License

---

📖 Project Overview

This project implements a complex floating-point division calculator using two PIC16F877A microcontrollers working in a master-slave architecture. The system can perform division operations on float numbers up to 1 million (10⁶) with decimal precision up to 6 digits (e.g., 999999.999999).

🎯 Key Features

• Dual MCU Architecture: Master-Slave communication using USART
• Floating-Point Precision: 6.6 fixed-point arithmetic (6 integer + 6 decimal digits)
• Interactive Input: Push-button digit entry with timeout and double-click detection
• LCD Display: 16×2 character display with cursor control
• Hardware Simulation: Complete Proteus simulation environment

---

🏗️ System Architecture

🔧 Hardware Components

Component	Quantity	Description	Connection
PIC16F877A	2	Master CPU & Co-processor	USART Communication
16×2 LCD	1	Character Display	4-bit mode to Master PORTD
Push Button	1	Input Interface	Master PORTB.0
4MHz Crystal	2	System Clock	Each MCU
Resistors	Various	Pull-up resistors	4.7KΩ, 10KΩ
Capacitors	4	Crystal oscillators	15pF each

🖥️ Component Layout

Master CPU (16F877A)

• PORTB.0: Push Button Input
• PORTD: LCD Interface (4-bit mode)
• PORTC: USART Communication
• MCLR: 10KΩ Pull-up

Slave CPU (16F877A)

• PORTC: USART Communication
• PORTD: Status LEDs (Optional)
• MCLR: 10KΩ Pull-up

LCD Display (16×2)

• 4-bit Data Mode: D4-D7 → PORTD.4-7
• Control Pins: RS, EN → PORTD.2-3
• RS Pull-up: 4.7KΩ resistor

📷 Hardware Components Gallery

🔧 Individual Components

PIC16F877A Microcontroller	16×2 LCD Display	Push Button	4MHz Crystal
Main processing unit	User interface display	Input interface	System clock source

Pull-up Resistors	Capacitors (15pF)
4.7KΩ & 10KΩ values	Crystal oscillator caps

🔌 Complete Circuit Design

Complete Proteus simulation schematic showing the dual PIC16F877A architecture with Master-Slave communication, LCD interface, push button input, and all supporting components including crystals, resistors, and capacitors.

---

🔄 System Operation Flow

📱 User Interface Flow

graph TD
    A[System Power Up] --> B[Welcome Screen<br/>Blinks 3 times]
    B --> C[Number 1 Entry]
    C --> D[Integer Part Entry<br/>6 digits]
    D --> E[Decimal Part Entry<br/>6 digits]
    E --> F[Number 2 Entry]
    F --> G[Integer Part Entry<br/>6 digits]
    G --> H[Decimal Part Entry<br/>6 digits]
    H --> I[Division Calculation]
    I --> J[Display Result]
    J --> K{Button Press?}
    K -->|Single| L[Cycle Display<br/>Result/Num1/Num2]
    K -->|Double| C
    L --> K

Loading

🤝 Master-Slave Communication Protocol

sequenceDiagram
    participant M as Master CPU
    participant S as Slave CPU
    
    Note over M,S: Phase 1: Send First Number (12 digits)
    M->>S: Digit 0 (MSB)
    M->>S: Digit 1
    M->>S: Digit 2
    Note over M,S: ... (continue for all 12 digits)
    M->>S: Digit 11 (LSB)
    
    Note over M,S: Phase 2: Send Second Number (12 digits)
    M->>S: Digit 0 (MSB)
    M->>S: Digit 1
    M->>S: Digit 2
    Note over M,S: ... (continue for all 12 digits)
    M->>S: Digit 11 (LSB)
    
    Note over M,S: Phase 3: Receive Result (12 digits)
    S->>M: Result Digit 0
    S->>M: Result Digit 1
    S->>M: Result Digit 2
    Note over M,S: ... (continue for all 12 digits)
    S->>M: Result Digit 11

Loading

Communication Details:

• Protocol: Simple USART transmission without acknowledgment
• Baud Rate: 9600 bps
• Data Format: 8-bit, no parity, 1 stop bit
• Timing: 5ms delay between each byte transmission
• Flow: Sequential transmission of 12-digit numbers as individual bytes

---

💻 Software Architecture

🎛️ Master CPU Functions

🖥️ Display Management

• LCD Initialization: 4-bit mode setup
• Welcome Screen: Blinking animation
• Number Entry: Cursor positioning
• Result Display: Formatted output

🎮 Input Handling

• Button Debouncing: Clean signal processing
• Timeout Detection: Auto-advance after 1 second
• Double-Click: Fast navigation
• Digit Increment: 0-9 cycling

📡 Communication Protocol

; Master sends data without acknowledgment
usart_send_byte:
    BANKSEL TXSTA
    BTFSS   TXSTA, TRMT    ; Wait for transmit buffer empty
    GOTO    $-1
    BANKSEL TXREG
    MOVWF   TXREG          ; Send byte
    RETURN

; Transmission with 5ms delay between bytes
transmit_first_number_to_slave:
    CLRF    transmit_index
transmit_loop:
    MOVF    transmit_index, 0
    ADDLW   digit_array1_0
    MOVWF   FSR
    MOVF    INDF, 0
    CALL    usart_send_byte
    CALL    delay_5ms      ; 5ms delay between transmissions
    INCF    transmit_index, 1
    MOVF    transmit_index, 0
    SUBLW   .12
    BTFSS   STATUS, Z
    GOTO    transmit_loop
    RETURN

---

⚙️ Slave CPU Functions

🔢 Division Algorithm

The slave implements a 18×12 decimal division algorithm:

• Input Scaling: 12-digit dividend → 18-digit (shifted 6 places)
• Precision: 6.6 fixed-point arithmetic
• Algorithm: Long division with decimal precision

perform_18x12_division:
    ; Initialize 13-digit working remainder
    ; Process 18 dividend digits
    ; Generate 12 quotient digits (6.6 format)

🧮 Key Mathematical Operations

• Multi-digit Comparison: 13×12 number comparison
• Multi-digit Subtraction: With borrow propagation
• Fixed-Point Conversion: Integer to 6.6 format

---

🔬 Detailed Division Mechanism

The division algorithm implements a sophisticated decimal long division process designed for high-precision floating-point arithmetic:

📊 Data Structure & Scaling

; Input: 12-digit numbers (NNNNNN.DDDDDD format)
; Dividend scaling: 12 → 18 digits (shift left by 6 decimal places)
; Working remainder: 13 digits for overflow handling
; Final quotient: 12 digits (6.6 fixed-point format)

🔄 Algorithm Flow

1. Input Preparation:

   • Copy 12-digit dividend to upper 12 positions of 18-digit array
   • Clear lower 6 positions (equivalent to multiplying by 10^6)
   • Initialize 13-digit working remainder to zero
   • Set up quotient storage for 12 digits

2. Iterative Division Process:

   FOR each of 18 dividend digits:
       1. Shift working remainder left by 1 decimal place
       2. Bring down next dividend digit
       3. Count how many times divisor fits into current remainder
       4. Store count as quotient digit (if in quotient range)
       5. Subtract (count × divisor) from remainder

3. Precision Control:

   • First 6 iterations: Build integer part of quotient
   • Last 12 iterations: Generate quotient digits
   • Skip first 5 quotient positions to maintain 6.6 format

🧮 Core Operations

Multi-Digit Comparison (compare_13x12_numbers):

; Compares 13-digit working remainder with 12-digit divisor
; Returns: div_compare_result = 1 if remainder ≥ divisor
; Handles digit-by-digit comparison from MSB to LSB

Multi-Digit Subtraction (subtract_13x12_numbers):

; Performs remainder = remainder - divisor
; Implements decimal borrow propagation
; Uses ripple-borrow routines (b_f_h_d_x) for carry handling

Borrow Propagation System:

; Example: b_f_h_d_0 through b_f_h_d_11
; Each routine handles borrow from current digit to next higher digit
; Implements fall-through logic for cascading borrows
; Converts negative digits to positive with borrow from next position

📈 Example Calculation

Input: 123456.789012 ÷ 2.000000
1. Scale dividend: 123456.789012 → 123456789012.000000 (18 digits)
2. Divisor remains: 2.000000 (12 digits as: 2000000000000)
3. Division produces: 61728.394506 (6.6 format)
4. Result transmitted as 12 bytes: [0,6,1,7,2,8,3,9,4,5,0,6]

---

🛠️ Development Environment

📋 Prerequisites

• MPLAB IDE: PIC development environment
• Proteus: Circuit simulation software
• PIC16F877A: Target microcontroller knowledge

🔧 Build Instructions

1. Clone Repository

   git clone https://github.com/osaidnur/PIC-Float-Division-Calculator.git
   cd PIC-Float-Division-Calculator

2. MPLAB Setup

   • Open master/master.mcp for Master CPU project
   • Open slave/slave.mcp for Slave CPU project
   • Build both projects to generate .hex files

3. Proteus Simulation

   • Open Circuit.pdsprj
   • Load master.hex into Master PIC16F877A
   • Load slave.hex into Slave PIC16F877A
   • Run simulation

---

🎮 Usage Instructions

🚀 Getting Started

1. Power Up: System displays welcome message
2. Number Entry: Use push button to increment digits
3. Navigation:
   • Single Click: Increment current digit
   • Wait 1 second: Advance to next digit
   • Double Click: Skip to decimal part or next number
4. Calculation: Automatic after second number entry
5. Result Viewing: Button cycles through result/numbers

📊 Input Format

• Range: 0.000001 to 999999.999999
• Precision: 6 decimal places
• Format: NNNNNN.DDDDDD (6 integer + 6 decimal)

---

🎬 Demonstration

📹 Simulation Video

sample_run.mp4

📸 Screenshots

Welcome Screen

System startup with blinking welcome message

Number Entry

Interactive digit entry with cursor

Result Display

Final result with formatting

---

📁 Project Structure

PIC-Float-Division-Calculator/
├── 📄 README.md                    # This documentation
├── 📄 project4_description.pdf     # Original requirements
├── 🔌 Circuit.pdsprj              # Proteus simulation file
├── 📁 master/                      # Master CPU code
│   ├── 📄 master.asm              # Main assembly source
│   ├── 📄 master.hex              # Compiled hex file
│   ├── 📄 master.mcp              # MPLAB project
│   ├── 📄 16f877a_g.lkr          # Linker script
│   ├── 📄 LCDIS.INC              # LCD library
│   └── 📄 P16F877A.INC           # MCU definitions
├── 📁 slave/                       # Slave CPU code
│   ├── 📄 slave.asm               # Main assembly source
│   ├── 📄 slave.hex               # Compiled hex file
│   └── 📄 slave.mcp               # MPLAB project
├── 📁 Project Backups/            # Automatic backups
└── 📁 images/                      # Documentation images

---

🔬 Technical Specifications

⚡ Performance Metrics

• Clock Speed: 4 MHz per MCU
• Communication: 9600 baud USART
• Precision: 6 decimal places
• Response Time: < 2 seconds for division
• Memory Usage: ~80% of available RAM

🎯 Algorithm Complexity

• Time Complexity: O(n×m) = O(18 × 12) = = O(216) elementary operations
• Space Complexity: 43 bytes for division variables
• Precision: Maintains 6 decimal places throughout calculation
• Range: Handles dividends up to 999999.999999
• Decimal Operations: BCD-like digit manipulation
• Communication: Interrupt-driven for efficiency

---

👥 Contributors

🌟 Meet Our Amazing Team

Ahmad Hussin

Moath Wajeeh

Moaid Karakra

Osaid Nur

🤝 Team Collaboration Stats

---

📜 License

This project is licensed under the Apache License - see the LICENSE file for details.

---