From f467eaa3f2500fac82ea07aebdd286e71cbcf369 Mon Sep 17 00:00:00 2001
From: etsmit <etsmit12@gmail.com>
Date: Fri, 18 Sep 2020 15:36:13 -0400
Subject: [PATCH 1/2] added basic SRRC pulsed BPSK

still needs work
---
 .DS_Store | Bin 8196 -> 8196 bytes
 signal.py |  83 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 83 insertions(+)

diff --git a/.DS_Store b/.DS_Store
index 36f3dafc7e862f0e1b5a4d92b61b84dd94cc0009..49a8869284b9710d26a4c4b40dc67dd8924ee99b 100644
GIT binary patch
delta 18
ZcmZp1XmQveCdkMz`GT<IW&^=1d;mBd1;zjX

delta 18
ZcmZp1XmQveCdkM*`GT<IW&^=1d;mBn1;+pY

diff --git a/signal.py b/signal.py
index f41a6db..90fee33 100644
--- a/signal.py
+++ b/signal.py
@@ -63,6 +63,89 @@ def rp_bpsk(nbits, tbit, fc, Ebit=0.0, N0=None):
     return x
 
 
+def srrc_pulse(beta,span,tbit):
+    #using p(t) from https://www.gaussianwaves.com/2018/10/square-root-raised-cosine-pulse-shaping/
+    x = np.arange(span)
+    b = beta
+    pi = np.pi
+    
+    #the function has discontinuities at x=0 and x = 10/(4*b) so
+    with np.errstate(divide='ignore'):
+        num = np.sin( (pi*x*(1-b))/(tbit) ) + ((4*b*(x))/(tbit))*np.cos( (pi*x*(1+b))/(tbit) )
+        den = ((pi*x)/(tbit)) * (1 - ( (4*b*x)/(tbit))**2 )
+
+        pulse = (1/np.sqrt(tbit)) * (num/den)
+    
+    #handle discontinuities
+    pulse[0] = (1/np.sqrt(tbit))*((1-b)+(4*b/pi))
+    
+    if (b != 0):
+        if ((tbit/(4*b)) == int(tbit/(4*b))) and ((tbit/(4*b)) <= span):
+            print(b)
+            print(int(tbit/(4*b)))
+            pulse[int(tbit/(4*b))] = ((b)/(np.sqrt(2*tbit))) * ( (1+2/pi)*np.sin(pi/(4*b)) + (1-2/pi)*np.cos(pi/(4*b)) )
+    
+    pulse = np.roll(pulse,len(pulse)//2)
+    pulse[:len(pulse)//2] = np.flip(pulse[len(pulse)//2:])
+    
+    return pulse
+
+
+
+def srrc_bpsk(nbits, tbit, fc, beta, Ebit=0.0, N0=None,fs=800e6):
+    """
+    Generate a rectangular pulse binary phase shift keyed signal.
+
+    Parameters
+    ----------
+    nbits : int
+        Number of bits to generate.
+    tbit : int
+        Bit duration (seconds).  The bit rate is 1/tbit.
+    fc : float
+        Carrier frequency (normalized units)
+    Ebit : float
+        Energy per bit (dB).
+    N0 : float
+        Noise power spectral density (dB).  If None, do not add noise.
+    
+    Returns
+    -------
+    out : ndarray
+       An array of size nbit containing the complex rectangular pulse BPSK
+       signal.
+
+    Examples
+    --------
+    >> rp_bpsk(10000,10,0.05,Ebit=10,N0=-10)
+    array([ 3.27208358+0.58731289j,  5.98561690+2.07007302j,
+        7.60758519+5.56195842j, ..., -3.73780915+5.00217463j,
+        0.02360099+0.1760474j , -0.09160716+0.18982198j])
+    """
+    #create random bit/symbol seq
+    bit_seq = np.random.randint(0,2,size=nbits)
+    
+    sym_seq = 2*bit_seq-1
+    extend = np.zeros(tbit)
+    extend[0]=1
+    sym_seq = np.kron(sym_seq,extend)
+    
+    #make srrc pulse functions
+    betas = np.arange(0,1,0.1)
+    res = np.empty((10,len(sym_seq)))
+    
+    for i in range(len(betas)):
+        pulse = srrc_pulse(betas[i],4000,4000)
+        x = lfilter(pulse, 1, sym_seq)
+        res[i,:] = x
+
+
+    return res
+
+
+
+
+
 
 #quadrature phase shift keying
 #same as binary phase shift, but information encoded is 2-bit, leading to 4 phases (45deg,135,225,315)

From 81ae7c7d81ad2bf15869522092095e79cd5083b0 Mon Sep 17 00:00:00 2001
From: etsmit <etsmit12@gmail.com>
Date: Sun, 20 Sep 2020 10:56:31 -0400
Subject: [PATCH 2/2] SRRC update pt 2

---
 signal.py | 34 +++++++++++++++++++++-------------
 1 file changed, 21 insertions(+), 13 deletions(-)

diff --git a/signal.py b/signal.py
index 90fee33..82ba2b7 100644
--- a/signal.py
+++ b/signal.py
@@ -92,7 +92,7 @@ def srrc_pulse(beta,span,tbit):
 
 
 
-def srrc_bpsk(nbits, tbit, fc, beta, Ebit=0.0, N0=None,fs=800e6):
+def srrc_bpsk(nbits, tbit, fc, beta, Ebit=0.0,fs=800e6):
     """
     Generate a rectangular pulse binary phase shift keyed signal.
 
@@ -103,11 +103,14 @@ def srrc_bpsk(nbits, tbit, fc, beta, Ebit=0.0, N0=None,fs=800e6):
     tbit : int
         Bit duration (seconds).  The bit rate is 1/tbit.
     fc : float
-        Carrier frequency (normalized units)
+        Carrier frequency (Hz).
+    beta : float
+        rollover factor for pulse shape. Between 0 and 1.
     Ebit : float
         Energy per bit (dB).
-    N0 : float
-        Noise power spectral density (dB).  If None, do not add noise.
+    fs : float
+        sampling frequency (Hz).
+
     
     Returns
     -------
@@ -117,11 +120,14 @@ def srrc_bpsk(nbits, tbit, fc, beta, Ebit=0.0, N0=None,fs=800e6):
 
     Examples
     --------
-    >> rp_bpsk(10000,10,0.05,Ebit=10,N0=-10)
+    >> rp_bpsk(10000,10,250e6,0.5,Ebit=10,N0=-10)
     array([ 3.27208358+0.58731289j,  5.98561690+2.07007302j,
         7.60758519+5.56195842j, ..., -3.73780915+5.00217463j,
         0.02360099+0.1760474j , -0.09160716+0.18982198j])
     """
+    ts = 1/fs
+    Ebit_linear = 10**(Ebit/10.0)
+    
     #create random bit/symbol seq
     bit_seq = np.random.randint(0,2,size=nbits)
     
@@ -130,17 +136,19 @@ def srrc_bpsk(nbits, tbit, fc, beta, Ebit=0.0, N0=None,fs=800e6):
     extend[0]=1
     sym_seq = np.kron(sym_seq,extend)
     
-    #make srrc pulse functions
-    betas = np.arange(0,1,0.1)
-    res = np.empty((10,len(sym_seq)))
+    #make srrc pulse function
+    pulse = srrc_pulse(beta,4000,4000)
     
-    for i in range(len(betas)):
-        pulse = srrc_pulse(betas[i],4000,4000)
-        x = lfilter(pulse, 1, sym_seq)
-        res[i,:] = x
+    
+    x = lfilter(pulse, 1, sym_seq)
+    
+    #apply to carrier frequency
+    arg = 2.j*np.pi*fc*ts*np.arange(len(x))
+    s = E_bit_linear*x*np.exp(arg)
+
 
 
-    return res
+    return s