Scribd
Upload
14 views18 pages

DC Assignment

This document is an assignment for the IT-207 Data Communications course at Delhi Technological University, detailing various line coding techniques. It includes code implementations for different encoding schemes such as Unipolar NRZ, Polar NRZ-L, Manchester, and more, along with their graphical outputs. The assignment is structured with an index and sections covering multiple coding techniques and their respective Python code examples.

Uploaded by

AYUSH XI-A 24
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
14 views18 pages

DC Assignment

This document is an assignment for the IT-207 Data Communications course at Delhi Technological University, detailing various line coding techniques. It includes code implementations for different encoding schemes such as Unipolar NRZ, Polar NRZ-L, Manchester, and more, along with their graphical outputs. The assignment is structured with an index and sections covering multiple coding techniques and their respective Python code examples.

Uploaded by

AYUSH XI-A 24
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd

DELHI TECHNOLOGICAL UNIVERSITY

(Formerly Delhi College of Engineering)


Shahbad Daulatpur, Bawana Road, New Delhi 110042)

DEPARTMENT OF INFORMATION TECHNOLOGY

IT-207: Data Communications


Line Coding Assignment

Submitted To: Submitted By:


[Link]
Dr. VirenderRanga
Ranga Ansh Gupta(24/IT/024)
Rahul (23/IT/127)
INDEX

[Link]. Description Page No. Signature

1. Unipolar - NRZ 2

2. Polar - NRZ - L 3

Polar - NRZ - I 4

Polar - RZ 5

Polar - Biphase - Manchester 6

Polar - Biphase - Differential Manchester 7

3. Bipolar - AMI 8

Bipolar - Pseudo Ternary 9

4. Multilevel - 2B1Q 10-11

Multilevel - 8B6T 12-13

Multilevel - 4D-PAM5 14

5. Multi-Transition - MLT-3 15

6. 16.

1
Unipolar

(i) NRZ (Non-Return to Zero)

Code:-
import [Link] as plt
import numpy as np
def unipolar_nrz(binary_string):
bit_time = 1
time = [Link](0, len(binary_string) * bit_time, 0.01)
signal = []
for bit in binary_string:
if bit == '1':
[Link]([1] * int(100 * bit_time))
elif bit == '0':
[Link]([0] * int(100 * bit_time))
[Link](figsize=(7, 3))
[Link](time, signal, where='post')
[Link]("Unipolar NRZ Line Coding")
[Link]("Time")
[Link]("Amplitude")
[Link](-0.5, 1.5)
[Link](True)
[Link]()
binary_string = input("Enter a binary string (only 0s and 1s): ")
unipolar_nrz(binary_string)

Output:-

2
Polar

(i) NRZ-L (Non-Return to Zero - Level)

Code:-
import [Link] as plt
import numpy as np
def polar_nrz_level(binary_string):
bit_time = 1
time = [Link](0, len(binary_string) * bit_time, 0.01)
signal = []
for bit in binary_string:
if bit == '0':
[Link]([1] * int(100 * bit_time)) # Level 1 for '0'
else:
[Link]([-1] * int(100 * bit_time)) # Level -1 for '1'
[Link](figsize=(7, 3))
[Link](time, signal, where='post')
[Link]("Polar NRZ-Level Line Coding")
[Link]("Time")
[Link]("Amplitude")
[Link](-1.5, 1.5)
[Link](True)
[Link]()
binary_string = input("Enter a binary string (only 0s and 1s): ")
polar_nrz_level(binary_string)

Output:-

3
(ii) NRZ-I (Non-Return to Zero - Inverted)

Code:-
import [Link] as plt
import numpy as np
def polar_nrz_inverted(binary_string):
bit_time = 1
time = [Link](0, len(binary_string) * bit_time, 0.01)
signal = []
current_level = 1
for bit in binary_string:
if bit == '1':
current_level *= -1
[Link]([current_level] * int(100 * bit_time))
[Link](figsize=(7, 3))
[Link](time, signal, where='post')
[Link]("Polar NRZ-Inverted (NRZI) Line Coding")
[Link]("Time")
[Link]("Amplitude")
[Link](-1.5, 1.5)
[Link](True)
[Link]()
binary_string = input("Enter a binary string: ")
polar_nrz_inverted(binary_string)

Output:-

4
(iii) RZ (Return to Zero)

Code:-
import [Link] as plt
import numpy as np
def rz(binary_string):
bit_time = 1
time = [Link](0, len(binary_string) * bit_time, 0.01)
signal = []
for bit in binary_string:
if bit == '1':
[Link]([1] * 50 + [0] * 50)
else:
[Link]([-1] * 50 + [0] * 50)
[Link](figsize=(7, 3))
[Link](time, signal, where='post')
[Link]("Return-to-Zero (RZ) Line Coding")
[Link]("Time")
[Link]("Amplitude")
[Link](-1.5, 1.5)
[Link](True)
[Link]()
binary_string = input("Enter a binary string: ")
rz(binary_string)

Output:-

5
(iv) Biphase

(a) Manchester Scheme

Code:-
import [Link] as plt
import numpy as np
def manchester(binary_string):
bit_time = 1
time = [Link](0, len(binary_string) * bit_time, 0.01)
signal = []
for bit in binary_string:
if bit == '1':
[Link]([-1] * 50 + [1] * 50)
else:
[Link]([1] * 50 + [-1] * 50)
[Link](figsize=(7, 3))
[Link](time, signal, where='post')
[Link]("Manchester Encoding")
[Link]("Time")
[Link]("Amplitude")
[Link](-1.5, 1.5)
[Link](True)
[Link]()
binary_string = input("Enter a binary string: ")
manchester(binary_string)

Output:-

6
(b) Differential Manchester Scheme

Code:-
import [Link] as plt
import numpy as np
def differential_manchester(binary_string):
bit_time = 1
time = [Link](0, len(binary_string) * bit_time, 0.01)
signal = []
current_level = 1
for bit in binary_string:
if bit == '0':
current_level *= -1
[Link]([current_level] * 50)
current_level *= -1
[Link]([current_level] * 50)
[Link](figsize=(10, 4))
[Link](time, signal, where='post')
[Link]("Differential Manchester Encoding")
[Link]("Time")
[Link]("Amplitude")
[Link](-1.5, 1.5)
[Link](True)
[Link]()
binary_string = input("Enter a binary string: ")
differential_manchester(binary_string)

Output:-

7
Bipolar

(i) AMI (Alternate Mark Inversion)

Code:-
import [Link] as plt
import numpy as np
def bipolar_ami(binary_string):
bit_time = 1
time = [Link](0, len(binary_string) * bit_time, 0.01)
signal = []
current_level = 1
for bit in binary_string:
if bit == '1':
[Link]([current_level] * 100)
current_level *= -1
else:
[Link]([0] * 100)
[Link](figsize=(7, 3))
[Link](time, signal, where='post')
[Link]("Bipolar AMI")
[Link]("Time")
[Link]("Amplitude")
[Link](-1.5, 1.5)
[Link](True)
[Link]()
binary_string = input("Enter a binary string: ")
bipolar_ami(binary_string)

Output:-

8
(i) Pseudo-Ternary

Code:-
import [Link] as plt
import numpy as np
def pseudoternary(binary_string):
bit_time = 1
time = [Link](0, len(binary_string) * bit_time, 0.01)
signal = []
current_level = 1
for bit in binary_string:
if bit == '0':
[Link]([current_level] * 100)
current_level *= -1
else:
[Link]([0] * 100)
[Link](figsize=(7, 3))
[Link](time, signal, where='post')
[Link]("Pseudoternary Encoding")
[Link]("Time")
[Link]("Amplitude")
[Link](-1.5, 1.5)
[Link](True)
[Link]()
binary_string = input("Enter a binary string: ")
pseudoternary(binary_string)

Output:-

9
Multilevel

(i) 2B1Q (2-Binary 1-Quaternary)

Code:-
import [Link] as plt
import numpy as np
def multilevel_2b1q(binary_string):
if len(binary_string) % 2 != 0:
print("Input binary string length must be even.")
return
prev = 1
negative = {
'00': -1,
'01': -3,
'10': 1,
'11': 3
}
positive = {
'00': 1,
'01': 3,
'10': -1,
'11': -3
}
bit_time = 1
time = [Link](0, len(binary_string) // 2 * bit_time, 0.01)
signal = []
for i in range(0, len(binary_string), 2):
pair = binary_string[i:i+2]
if prev > 0:
[Link]([positive[pair]] * 100)
prev = positive[pair]
else:
[Link]([negative[pair]] * 100)
prev = negative[pair]
[Link](figsize=(7, 3))
[Link](time, signal, where='post')
[Link]("2B1Q Encoding")
[Link]("Time")
[Link]("Amplitude (Quaternary Levels)")
[Link](-3.5, 3.5)
[Link](True)
[Link]()
binary_string = input("Enter a binary string (length must be even): ")
multilevel_2b1q(binary_string)

10
Output:-

11
(ii) 8B6T(8-Binary 6-Ternary)

Code:-
import [Link] as plt
import numpy as np
def multilevel_8b6t(binary_string):
if len(binary_string) % 8 != 0:
print("Input binary string length must be a multiple of 8.")
return
mapping = {
'00000000': [-1, -1, -1, -1, -1, -1],
'00000001': [-1, -1, -1, -1, -1, 0],
'00000010': [-1, -1, -1, -1, 0, 1],
'00000011': [-1, -1, -1, 0, 1, 1],
'00000100': [-1, -1, 0, 1, 1, 0],
'00000101': [-1, 0, 1, 1, 0, 1],
'11111111': [1, 1, 1, 1, 1, 1],
'10101010': [1, 0, 1, 0, 1, 0],
'11001100': [1, 1, 0, 0, 1, 1],
}
bit_time = 1
total_bits = len(binary_string) // 8 * 6
time = [Link](1, total_bits + 1)
signal = []
for i in range(0, len(binary_string), 8):
group = binary_string[i:i+8]
if group in mapping:
[Link]([level for level in mapping[group]])
else:
print(f"Pattern {group} not in mapping.")
return
[Link](figsize=(7, 3))
[Link](time, signal, where='post')
[Link]("8B6T Encoding")
[Link]("Time")
[Link]("Amplitude (Ternary Levels)")
[Link](-2, 2)
[Link]([Link](1, total_bits + 1, 1))
[Link](True)
[Link]()
binary_string = input("Enter a binary string (length must be a multiple of 8): ")
multilevel_8b6t(binary_string)

12
Output:-

13
(iii) 4D-PAM5 (4-Dimensional Pulse Amplitude Modulation with 5 levels)

Code:-
import [Link] as plt
import numpy as np
def pam5_4d(binary_string):
if len(binary_string) % 4 != 0:
print("Input binary string length must be a multiple of 4.")
return
mapping = {
'00': -2,
'01': -1,
'10': 1,
'11': 2,
}
bit_time = 1
time = [Link](1, len(binary_string) // 2 + 1)
signal = []
for i in range(0, len(binary_string), 2):
pair = binary_string[i:i+2]
[Link](mapping[pair])
[Link](figsize=(7, 3))
[Link](time, signal, where='post')
[Link]("4D-PAM5 Encoding")
[Link]("Time")
[Link]("Amplitude (Levels -2, -1, 1, 2)")
[Link](-2.5, 2.5)
[Link]([Link](1, len(time) + 1, 1))
[Link](True)
[Link]()
binary_string = input("Enter a binary string (multiple of 4): ")
pam5_4d(binary_string)

Output:-

14
Multi-Transition

(i) MLT-3 (Multi level Transmit – 3 Levels))

Code:-
import [Link] as plt
import numpy as np
def mlt_3(binary_string):
bit_time = 1
time = [Link](0, len(binary_string) * bit_time, 0.01)
signal = []
state_sequence = [0, 1, 0, -1]
current_state = 0
state_index = 0
for bit in binary_string:
if bit == '1':
state_index = (state_index + 1) % 4
current_state = state_sequence[state_index]
[Link]([current_state] * 100)
[Link](figsize=(7, 3))
[Link](time, signal, where='post')
[Link]("MLT-3 Encoding")
[Link]("Time")
[Link]("Amplitude")
[Link](-1.5, 1.5)
[Link](True)
[Link]()
binary_string = input("Enter a binary string: ")
mlt_3(binary_string)

Output:-

15
Some Block coding Techniques
1. 4B/5B Encoding
(iv)
.
Code:-
import [Link] as plt

# 4B/5B Encoding and Decoding

# 4B/5B code mapping (IEEE 802.3 standard)


fourb_fiveb_table = {
"0000": "11110",
"0001": "01001",
"0010": "10100",
"0011": "10101",
"0100": "01010",
"0101": "01011",
"0110": "01110",
"0111": "01111",
"1000": "10010",
"1001": "10011",
"1010": "10110",
"1011": "10111",
"1100": "11010",
"1101": "11011",
"1110": "11100",
"1111": "11101"
}

fiveb_fourb_table = {v: k for k, v in fourb_fiveb_table.items()}

def encode_4b5b(binary_string):
if len(binary_string) % 4 != 0:
print("Input binary string length must be a multiple of 4.")
return
encoded = ""
for i in range(0, len(binary_string), 4):
nibble = binary_string[i:i+4]
encoded += fourb_fiveb_table[nibble]
print("4B/5B Encoded Output:", encoded)
return encoded

def decode_4b5b(encoded_string):
if len(encoded_string) % 5 != 0:
print("Input length must be multiple of 5.")
return
decoded = ""
for i in range(0, len(encoded_string), 5):
group = encoded_string[i:i+5]
decoded += fiveb_fourb_table[group]
print("Decoded Binary Output:", decoded)
return decoded

binary_string = input("Enter a binary string (multiple of 4): ")


encoded = encode_4b5b(binary_string)
if encoded:
decode_4b5b(encoded)

Output:-

(v) 8B/10B Encoding

Code:-
import [Link] as plt

# Simplified 8B/10B Encoding and Decoding (educational demo)

eightb_tenb_table = {
"00000000": "1001110100",
2.•

You might also like