freesopy 1.0.7

This is a Python package for the implementation of various equations of Free Space Optical Communication

Freesopy

A Python package for the implementation of various equations of Free Space Optical Communication

---

Freesopy is designed to simplify the implementation of various mathematical equations used in Free Space Optical Communication. It provides easy-to-use functions that can be integrated into your projects.

Usaage

You can import Freesopy as:

import freesopy as fso

Some General Equations

P_t: Transmitted power in mW
D_r: Receiver aperture diameter in meters
d: Distance between transmitter and receiver in meters
P_r: Received power in mW
L_p: Path loss in dB
N_0: Noise power spectral density in mW/Hz

Calculate Received Power

Power_received = fso.calculate_received_power(P_t, D_r, d)

Calculate Path Loss

Path_loss = fso.calculate_path_loss(P_t, P_r)

Calculate SNR

SNR = fso.calculate_snr(P_r, N_0)

Calculation of Losses

wl = wavelength
d= distance between transmitter and receiver
alpha= atmospheric attenuation coefficient
dt= diameter of transmitter antenna
dr = diameter of receiver antenna
pt = power total
pn = power of ambient noise
sigma_p = standard deviation of pointing error
sigma_s= standard deviation due to scintillation
gamma = initial intensity of optical beam
cn = refractive structure parameter
theta= angle of divergence
theta_mis = mismatch angle divergence

Attenuation Loss

attenuation_loss = fso.atmospheric_attenuation_loss(gamma, alpha, d)

Geometric Loss

geo_loss = fso.geometric_loss(dr, dt, d, wl, pt)

Misalignment Loss

misalignment_loss = fso.pointing_misalignment_loss(d, sigma_p, pt)

Atmospheric Turbulence

turbulence_loss = fso.atmospheric_turbulence(pt, cn, d, wl)

Polarising Loss Power

polarising_loss_power = fso.polarising_loss_power(pt, theta_mis)

Ambient Noise

ambient_noise = fso.ambient_noise(pt, pn)

Beam Divergence Loss

divergence_loss = fso.beam_divergence_loss(theta, d, pt)

Scintillation Loss

scintillation_loss = fso.scintillation_loss(sigma_s, pt)

General Graphs and Calculations

P_received : Received optical power (W)
responsivity : Responsivity of the photodetector (A/W)
T : Temperature (K)
B : Bandwidth (Hz)
R_load : Load resistance (Ohms)
I_photo : Photocurrent (A)
I_shot_squared : Shot noise squared (A^2)
I_thermal_squared : Thermal noise squared (A^2)
SNR : Signal-to-Noise Ratio (unitless)

SNR Calculations

I_photo = fso.calculate_photocurrent(P_received, responsivity)

I_thermal_squared = fso.calculate_thermal_noise(T, B, R_load)

I_shot_squared = fso.calculate_shot_noise(I_photo, B)

SNR = fso.calculate_SNR(I_photo, I_shot_squared, I_thermal_squared)

fso.plot_SNR(P_received, SNR)

Free Space Path Loss (FSPL)

f: Frequency (Hz)
d_range: Tuple defining the minimum and maximum distance in metres
num_points: Number of distance points to generate

fso.plot_fspl(f, d_range, num_points)

Divergence of Optical Beam

w_0: Initial beam waist (m)
lambda_light: Wavelength of the light (nm)
d_range: Tuple defining the minimum and maximum distance (meters)
num_points: Number of distance points to generate

fso.plot_beam_divergence(w_0, lambda_light, d_range, num_points)

Channel Modelling

Simulating the LOS channel gain

Parameters:

theta : (float) Semi-angle at half power (in degrees).
P_total : (float) Transmitted optical power by individual LED (in watts).
Adet : (float) Detector physical area of a PD (in square meters).
Ts : (float) Gain of an optical filter (default is 1 if no filter is used).
index : (float) Refractive index of a lens at a PD (default is 1.5 if no lens is used).
FOV : (float) Field of View of a receiver (in radians).
lx, ly, lz : (float) Room dimensions (in meters).
h : (float) Distance between the source and the receiver plane (in meters).
XT, YT : (float) Position of the LED (in meters).

fso.los_channel_gain(theta, P_total, Adet, Ts, index, FOV, lx, ly, lz, h, XT, YT)