Component-1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TRANSMITTER:\n",
    "\n",
    "\n",
    "TARS sends a msg.\n",
    "\n",
    "Steps 1: Encoder takes the msg converts to bits(Morse code)\n",
    "\n",
    "Steps 2: BPSK Modulation\n",
    "\n",
    "### Baseband to Passband Conversion\n",
    "\n",
    "### CHANNEL: AWGN\n",
    "\n",
    "### Passband to Baseband Conversion\n",
    "\n",
    "### RECEIVER:\n",
    "\n",
    "Step 1: Demodulation of signal\n",
    "\n",
    "Step 2:  Decoder decodes it.\n",
    "\n",
    "Cooper recives message."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#libraries used\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# convert the message to morse code( Format given in question of 0s and 1s)\n",
    "def msg_to_morse(message):\n",
    "    # Dictionary representing the morse code chart \n",
    "    MORSE_CODE_DICT = { 'A':'.-', 'B':'-...', \n",
    "                        'C':'-.-.', 'D':'-..', 'E':'.', \n",
    "                        'F':'..-.', 'G':'--.', 'H':'....', \n",
    "                        'I':'..', 'J':'.---', 'K':'-.-', \n",
    "                        'L':'.-..', 'M':'--', 'N':'-.', \n",
    "                        'O':'---', 'P':'.--.', 'Q':'--.-', \n",
    "                        'R':'.-.', 'S':'...', 'T':'-', \n",
    "                        'U':'..-', 'V':'...-', 'W':'.--', \n",
    "                        'X':'-..-', 'Y':'-.--', 'Z':'--..', \n",
    "                        '1':'.----', '2':'..---', '3':'...--', \n",
    "                        '4':'....-', '5':'.....', '6':'-....', \n",
    "                        '7':'--...', '8':'---..', '9':'----.', \n",
    "                        '0':'-----'} \n",
    "\n",
    "    # Convert MORSE dictionary into bits(0s and 1s) as per the format given\n",
    "    for k in MORSE_CODE_DICT:\n",
    "        MORSE_CODE_DICT[k]=MORSE_CODE_DICT[k].replace(\"\", \"0\")[1: -1]   # 1 unit space(0) between parts of same letter\n",
    "        MORSE_CODE_DICT[k]=MORSE_CODE_DICT[k].replace(\".\",'1')     # . represents 1 unit : 1\n",
    "        MORSE_CODE_DICT[k]=MORSE_CODE_DICT[k].replace(\"-\",'111')    # - represents 3 units : 111\n",
    "\n",
    "    # Function to encrypt the message \n",
    "    # according to the morse code chart \n",
    "    def encrypt(message): \n",
    "        cipher = '' \n",
    "        for letter in message: \n",
    "            if letter != ' ': \n",
    "\n",
    "                # Looks up the dictionary and adds the \n",
    "                # correspponding morse code \n",
    "                # along with 000 to separate \n",
    "                # morse codes for different characters \n",
    "                cipher += MORSE_CODE_DICT[letter] + '000'\n",
    "            else: \n",
    "                # 7 0's after each word (3 before+ 4 after) \n",
    "                cipher += '0000'\n",
    "\n",
    "        return cipher \n",
    "\n",
    "\n",
    "    encrypt_signal = encrypt(message) \n",
    "    encrypt_signal = encrypt_signal[:-3]   # to delete the last 3 000's added in the end\n",
    "    return encrypt_signal\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def modulation(encoded_array):\n",
    "    #--------Data to be transmitted-------#\n",
    "    unipolar_arr = encoded_array # unipolar : 0s and 1s\n",
    "    \n",
    "    #--------BPSK Mapping to symbols-------#\n",
    "    # As in a noisy channel the conversion of 0 & 1 is quite possible, we convert it into polar format(+1,-1)\n",
    "    bipolar = 2*unipolar_arr - 1   # bpsk mapping\n",
    "    \n",
    "    #-------Parameters Tuning-------#\n",
    "    bit_duration = 1\n",
    "    amplitude_scaling_factor = bit_duration/2  # This will result in unit amplitude waveforms\n",
    "    \n",
    "    n_samples = len(encoded_array) * 5   # number of samples to be taken\n",
    "    time = np.linspace(0, 5, n_samples)  \n",
    "    samples_per_bit = n_samples/unipolar_arr.size \n",
    "    \n",
    "    #--------Forming Continous pulse-------#\n",
    "    binary_data = np.repeat(unipolar_arr, samples_per_bit)  # replicate each bit Nsb times\n",
    "    mapped_data = np.repeat(bipolar, samples_per_bit)\n",
    "    \n",
    "    return binary_data,mapped_data,time,n_samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bb_to_pb(mapped_array,time):\n",
    "    #-------Parameters Tuning-------#\n",
    "    bit_duration = 1\n",
    "    amplitude_scaling_factor = bit_duration/2  # This will result in unit amplitude waveforms\n",
    "    freq = 3/bit_duration  # carrier frequency\n",
    "    waveform = np.sqrt(2*amplitude_scaling_factor/bit_duration) * np.cos(2*np.pi * freq * time)  # carrier signal\n",
    "    passband_sig = mapped_array*waveform    # modulated signal\n",
    "    \n",
    "    return passband_sig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define additive white Gaussian noise\n",
    "def channel(y, snr):\n",
    "     \n",
    "    np.random.seed(10)\n",
    "    snr = 10 ** (snr / 10.0)    # SNR(dB) to linear scale\n",
    " \n",
    "    xpower = np.sum(y ** 2) / len(y)   # signal Power \n",
    " \n",
    "    npower = xpower / snr   # Noise Power\n",
    "    \n",
    "    tx = np.random.randn(len(y)) * np.sqrt(npower) + y  # Add noise to modulated signal\n",
    "        \n",
    "    return tx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pb_to_bb(tx,time):\n",
    "    #-------Parameters Tuning-------#\n",
    "    bit_duration = 1\n",
    "    amplitude_scaling_factor = bit_duration/2  # This will result in unit amplitude waveforms\n",
    "    freq = 3/bit_duration  # carrier frequency\n",
    "    \n",
    "    #-------Carrier Signal---------#\n",
    "    waveform = np.sqrt(2*amplitude_scaling_factor/bit_duration) * np.cos(2*np.pi * freq * time)  # carrier signal\n",
    "    \n",
    "    #-------Demodulation---------#\n",
    "    base_band_sig=tx*waveform     # demodulated signal\n",
    "    \n",
    "    return base_band_sig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decode(dem,n_samples):\n",
    "    k=0\n",
    "    rx=[]\n",
    "    rx_unipolar=[]\n",
    "    samples_per_bit=5   #samples per bit taken earlier\n",
    "    n=int(n_samples/samples_per_bit)\n",
    "    for i in range(0,n):\n",
    "        sm=0\n",
    "        for j in range(0,samples_per_bit):\n",
    "            sm=sm+dem[k]\n",
    "            k=k+1\n",
    "        if(sm>0):\n",
    "            rx.append(1)\n",
    "            rx_unipolar.append(1)\n",
    "        else:\n",
    "            rx.append(-1)\n",
    "            rx_unipolar.append(0)\n",
    "    \n",
    "    \n",
    "    rrx = np.repeat(rx, samples_per_bit)    # from pulse\n",
    "    rx_s=''.join(map(str, rx_unipolar)) \n",
    "    time = np.linspace(0, 5, n_samples)\n",
    "\n",
    "    return rx,rx_s,rrx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def morse_to_msg(rx_s):\n",
    "    #-----------------------------Dictionary representing the morse code chart------------------------------------------# \n",
    "    MORSE_CODE_DICT = { 'A':'.-', 'B':'-...', \n",
    "                        'C':'-.-.', 'D':'-..', 'E':'.', \n",
    "                        'F':'..-.', 'G':'--.', 'H':'....', \n",
    "                        'I':'..', 'J':'.---', 'K':'-.-', \n",
    "                        'L':'.-..', 'M':'--', 'N':'-.', \n",
    "                        'O':'---', 'P':'.--.', 'Q':'--.-', \n",
    "                        'R':'.-.', 'S':'...', 'T':'-', \n",
    "                        'U':'..-', 'V':'...-', 'W':'.--', \n",
    "                        'X':'-..-', 'Y':'-.--', 'Z':'--..', \n",
    "                        '1':'.----', '2':'..---', '3':'...--', \n",
    "                        '4':'....-', '5':'.....', '6':'-....', \n",
    "                        '7':'--...', '8':'---..', '9':'----.', \n",
    "                        '0':'-----'} \n",
    "\n",
    "    for k in MORSE_CODE_DICT:\n",
    "        MORSE_CODE_DICT[k]=MORSE_CODE_DICT[k].replace(\"\", \"0\")[1: -1]\n",
    "        MORSE_CODE_DICT[k]=MORSE_CODE_DICT[k].replace(\".\",'1')\n",
    "        MORSE_CODE_DICT[k]=MORSE_CODE_DICT[k].replace(\"-\",'111')\n",
    "    \n",
    "    #--------------------------------------Detecting words and letters--------------------------------------------------#\n",
    "    \n",
    "    #The idea is to detect number of 0's in the signal:\n",
    "    #if 3 consecutive 0's are found: Replace them by  'L' --> New Letter Found\n",
    "    #if 7 consecutive 0's are found: Replace them by  'W' --> New Word Found\n",
    "    \n",
    "    # param: s(message), newstring('L or W'),index1:index2--> Indices of 0's in the message \n",
    "    def replacer(s, newstring, index1,index2):\n",
    "        if index1 < 0:  # add it to the beginning\n",
    "            return newstring + s\n",
    "        if index2 > len(s):  # add it to the end\n",
    "            return s + newstring\n",
    "\n",
    "        # insert the new string between \"slices\" of the original\n",
    "        return s[:index1] + newstring + s[index2 + 1:]     # all the 0's are replaced by 'L' or 'W' accordingly\n",
    "\n",
    "   \n",
    "    rx_msg_1=''\n",
    "    l=0  # for letter count\n",
    "    for j in rx_s:\n",
    "        rx_msg_1=''.join((rx_msg_1,j))\n",
    "        # Bit joined in rx_msg_1: j\n",
    "        if j!='0':\n",
    "            # Bit is  1\n",
    "            count=0   # for 0's count\n",
    "            if l==1:  #letter count\n",
    "                #letter changed\n",
    "                #change last 3 words to 'L'\n",
    "                rx_msg_1=replacer(rx_msg_1, 'L',len(rx_msg_1)-4 ,len(rx_msg_1)-2)\n",
    "                l=0    #make l=0 for avoiding further interference\n",
    "        else:\n",
    "            # Bit is  0\n",
    "            count = count+1    # zero's count increment\n",
    "            #if 3 0's:Letter may be changed or Words may be changed if 0's get further incremented by 7\n",
    "            if (count==3):  \n",
    "                l=1     # letter's count incremented\n",
    "            else:\n",
    "                l=0     \n",
    "            if count==7:\n",
    "                #print(\"Word Detected\")\n",
    "                #word changed\n",
    "                #change the lat 7 words to 'W'\n",
    "                rx_msg_1=replacer(rx_msg_1, 'W',len(rx_msg_1)-7 ,len(rx_msg_1)-1)\n",
    "                \n",
    "                \n",
    "\n",
    "    #print(\"Words and Letters Detected: \" , rx_msg_1)\n",
    "     #-------------------------------------Decipher the code-----------------------------------------------------------# \n",
    "    # Decrpyt this modified signal\n",
    "    def decrypt(message): \n",
    "  \n",
    "        # extra space added at the end to access the \n",
    "        # last morse code \n",
    "        message += ' '\n",
    "\n",
    "        decipher = '' \n",
    "        citext = '' \n",
    "        for letter in message: \n",
    "\n",
    "            if (letter == '1' or letter == '0'): \n",
    "                # storing morse code of a single character \n",
    "                citext += letter \n",
    "\n",
    "            # in case of letter\n",
    "            elif letter=='L':\n",
    "               \n",
    "                # if i = l that indicates a new letter\n",
    "                # accessing the keys using their values (reverse of encryption) \n",
    "                # Test if element is dictionary value  \n",
    "                res = citext in MORSE_CODE_DICT.values() \n",
    "                if res == 1:\n",
    "                    decipher += list(MORSE_CODE_DICT.keys())[list(MORSE_CODE_DICT.values()).index(citext)]\n",
    "                else:\n",
    "                    decipher += '$' # if due to noise the particular sequence is not found: $ is choosen\n",
    "                citext = '' \n",
    "            \n",
    "            else: # it is a new word\n",
    "                # adding space to separate words \n",
    "                res = citext in MORSE_CODE_DICT.values()\n",
    "                if res == 1:\n",
    "                    decipher += list(MORSE_CODE_DICT.keys())[list(MORSE_CODE_DICT.values()).index(citext)]\n",
    "                else:\n",
    "                    decipher += '$'\n",
    "                decipher += ' '\n",
    "                citext = '' \n",
    "\n",
    "\n",
    "        return decipher \n",
    "     #-------------------------------------Return the final decrypted message----------------------------------------# \n",
    "    rx_msg=decrypt(rx_msg_1)\n",
    "    #print(\" Final Received Message: \",rx_msg)\n",
    "    return rx_msg\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MAIN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TARS's Message to Send :  MISSION COMPLETED WHAT IS YOUR STATUS\n",
      "Encrpted Message :  11101110001010001010100010101000101000111011101110001110100000001110101110100011101110111000111011100010111011101000101110101000100011100010001110101000000010111011100010101010001011100011100000001010001010100000001110101110111000111011101110001010111000101110100000001010100011100010111000111000101011100010101\n",
      "Recieved message :  11101110001010001010100010101000101010111011101110001110100000001111101110100011101110111000111011100010111011101000101110101000110011100010101110101000000010111011100010101010001011100011100000001010001010100000101110101100111000111011101110001010111000101110100000001010100011100010111000111001101011100010101\n",
      " Final Received Message:  MISS$N $OMPL$$ WHAT I$OUR STA$S \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#-------------------------------------------------Transmitter End--------------------------------------------------------#\n",
    "\n",
    "#-------TARS Sends MSG--------#\n",
    "\n",
    "message = \"MISSION COMPLETED WHAT IS YOUR STATUS\"             \n",
    "print(\"TARS's Message to Send : \",message)\n",
    "\n",
    "#--------- Conersion TO Morse Code Bits Pattern:Channel Encoder----------#\n",
    "\n",
    "encrypt_signal= msg_to_morse(message)\n",
    "print(\"Encrpted Message : \",encrypt_signal)\n",
    "encoded_array = np.array([int(x) for x in encrypt_signal])  # converted string into int array for further purposes\n",
    "\n",
    "#--------BPSK Modulation-----#\n",
    "\n",
    "binary_data,mapped_data,time,n_samples = modulation(encoded_array)\n",
    "mapped_array = np.array([int(x) for x in mapped_data])  # converted string into int array for further purposes\n",
    "binary_array = np.array([int(x) for x in binary_data])  # converted string into int array for further purposes\n",
    "#Note: n_samples and time are taken for ease in plotting and visualisation purpose in further steps.\n",
    "\n",
    "#--------------------------------------Baseband-to-Passband-COnversion----------------------------------------------------#\n",
    "\n",
    "pass_band=bb_to_pb(mapped_array,time)\n",
    "\n",
    "#-----------------------------------------------Transmission: AWGN Channel------------------------------------------------#\n",
    "\n",
    "snr = 10  #set snr value=10dB  (random selection)\n",
    "tx = channel(pass_band, snr)   # transmitted signal\n",
    "\n",
    "#-------------------------------------Passband-to-Baseband-COnversion-----------------------------------------------------#\n",
    "\n",
    "base_band=pb_to_bb(tx,time)\n",
    "\n",
    "#--------------------------------------------Receiver End-----------------------------------------------------------------#\n",
    "\n",
    "rx,rx_s,rrx=decode(base_band,n_samples)  # received signal\n",
    "print(\"Recieved message : \",rx_s)\n",
    "\n",
    "#-------Cooper Reads This MSG--------#\n",
    "message_received = morse_to_msg(rx_s)\n",
    "print(\" Final Received Message: \",message_received)\n",
    "\n",
    "#-------------------------------------------Plotting----------------------------------------------------------------------#\n",
    "#------Plotting-------#\n",
    "f, ax = plt.subplots(6,1, sharex=True, sharey=True)\n",
    "# plot binary data pulse\n",
    "ax[0].plot(time, binary_array)  \n",
    "ax[0].set_title('Encoded Binary Data Pulse')\n",
    "    \n",
    "#plot bipolar/mapped pulse\n",
    "ax[1].plot(time,mapped_array)\n",
    "ax[1].set_title('Mapped Data pulse')\n",
    "    \n",
    "#plot Passband signal\n",
    "ax[2].plot(time, pass_band, '.')\n",
    "ax[2].set_title('Passband Signal')\n",
    "\n",
    "#plot Transmitted Signal\n",
    "ax[3].plot(time, tx, '.')\n",
    "ax[3].set_title('Transmitted Signal')\n",
    "\n",
    "#plot Baseband Signal\n",
    "ax[4].plot(time, base_band, '.')\n",
    "ax[4].set_title('Baseband Signal')\n",
    "\n",
    "#plot Received Signal\n",
    "ax[5].plot(time, rrx)\n",
    "ax[5].set_title('Received Pulse')\n",
    "\n",
    "ax[5].set_xlabel('time')\n",
    "    \n",
    "#set axis\n",
    "ax[0].axis([0, 5, -1.5, 1.5])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Error rate vs SNR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# finds number of operations to convert str1 to str2\n",
    "def editDistDP(str1, str2, m, n): \n",
    "    # Create a table to store results of subproblems \n",
    "    dp = [[0 for x in range(n + 1)] for x in range(m + 1)] \n",
    "  \n",
    "    # Fill d[][] in bottom up manner \n",
    "    for i in range(m + 1): \n",
    "        for j in range(n + 1): \n",
    "  \n",
    "            # If first string is empty, only option is to \n",
    "            # insert all characters of second string \n",
    "            if i == 0: \n",
    "                dp[i][j] = j    # Min. operations = j \n",
    "  \n",
    "            # If second string is empty, only option is to \n",
    "            # remove all characters of second string \n",
    "            elif j == 0: \n",
    "                dp[i][j] = i    # Min. operations = i \n",
    "  \n",
    "            # If last characters are same, ignore last char \n",
    "            # and recur for remaining string \n",
    "            elif str1[i-1] == str2[j-1]: \n",
    "                dp[i][j] = dp[i-1][j-1] \n",
    "  \n",
    "            # If last character are different, consider all \n",
    "            # possibilities and find minimum \n",
    "            else: \n",
    "                dp[i][j] = 1 + min(dp[i][j-1],        # Insert \n",
    "                                   dp[i-1][j],        # Remove \n",
    "                                   dp[i-1][j-1])    # Replace \n",
    "  \n",
    "    return dp[m][n] \n",
    "  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#  Error rate Calculation\n",
    "#-----------------------------------------Original-Signal Sent is encrypt signal---------------------------------------# \n",
    "\n",
    "N=len(message)-message.count(\" \")  #total letters in message\n",
    "N_W=len(message.split())  #total words in message\n",
    "#----------------------Parameters-----------------------------------------------------------------------------------#\n",
    "EbNodB_range = range(0,15)   # SNR Varying Range\n",
    "itr = len(EbNodB_range)\n",
    "ler = [None]*itr            # letters error rate\n",
    "wer = [None]*itr            # words error rate\n",
    "\n",
    "for n in range(0,itr):\n",
    "    \n",
    "    #----------------------Transmission: AWGN Channel----------------------#\n",
    "    snr = EbNodB_range[n]  \n",
    "    tx = channel(pass_band, snr)   # transmitted signal\n",
    "\n",
    "    #----------------Passband-to-Baseband-COnversion-----------------------#\n",
    "\n",
    "    base_band=pb_to_bb(tx,time)\n",
    "\n",
    "    #------------------------Receiver End------------------------------#\n",
    "\n",
    "    rx,rx_s,rrx=decode(base_band,n_samples)  # received signal\n",
    "    #print(\"Recieved message : \",rx_s)\n",
    "    \n",
    "    #-------Cooper Reads This MSG--------#\n",
    "    message_received = morse_to_msg(rx_s)\n",
    "\n",
    "    #------------------------Letter Error Rate Calculation------------------------------#\n",
    "    \n",
    "    str1 = message_received.replace(\" \", \"\")\n",
    "    str2 = message.replace(\" \", \"\")\n",
    "\n",
    "    letter_error=editDistDP(str1, str2, len(str1), len(str2))\n",
    "    ler[n] = 1.0 * letter_error / N\n",
    "    #------------------------Word Error Rate Calculation------------------------------#\n",
    "    A=message\n",
    "    B=message_received\n",
    "    un_comm = [i for i in \"\".join(B).split() if i not in \"\".join(A).split()] # Finding uncommon words\n",
    "    word_error=len(un_comm)\n",
    "    wer[n] = 1.0 * word_error / N_W\n",
    "    \n",
    "#----------------------------------------------Plotting------------------------------------------------------------------#\n",
    "\n",
    "plt.plot(EbNodB_range, ler)\n",
    "plt.xscale('linear')\n",
    "plt.yscale('log')\n",
    "plt.xlabel('EbNo(dB)')\n",
    "plt.ylabel('LER')\n",
    "plt.grid(True)\n",
    "plt.title('Letter Rate Error = No. of incorrect letters recieved/total number of letters sent')\n",
    "plt.show()       \n",
    "    \n",
    "plt.plot(EbNodB_range, wer)\n",
    "plt.xscale('linear')\n",
    "plt.yscale('log')\n",
    "plt.xlabel('EbNo(dB)')\n",
    "plt.ylabel('WER')\n",
    "plt.grid(True)\n",
    "plt.title('Word Rate Error = No. of incorrect words recieved/total number of words sent')\n",
    "plt.show() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}