Acquisition_template.ipynb


{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Radar Data Streaming and Pre-Processing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### This notebook demonstrates how to read the data from the radar using python wrapper for Infineon Radar SDK"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Importing required libraries \n",
    "\n",
    "    - ifxdaq --> is the python wrapper for Radar SDK\n",
    "    - processing --> is python module for basic processing to get the range-Dopplers from the signal\n",
    "    - fft --> contains the range_fft and doppler_fft methods\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#pip install ifxdaq-3.0.1-py3-none-win_amd64.whl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#pip install processing.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ifxdaq\n",
    "import processing\n",
    "import numpy as np\n",
    "#print(ifxdaq.__version__)\n",
    "from ifxdaq.sensor.radar_ifx import RadarIfxAvian\n",
    "import matplotlib.pyplot as plot\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### In the folder 'radar_configs' you find radar configuration parameters. It contains radar parameters :\n",
    "\n",
    "    - transmit power level\n",
    "    - start/end frequency\n",
    "    - sampling rate\n",
    "    - # of chirps per frame\n",
    "    - # of samples per chirp\n",
    "    - # of transmit/receive antennas\n",
    "    - MIMO mode selection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "config_file = \"radar_configs/RadarIfxBGT60.json\"\n",
    "number_of_frames = 3000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "With the current configuration, the radar will send out 64 signals with varying frequency (\"chirps\") between 60.5 GHz and 61.5 GHz.\n",
      "Each chirp will consist of 128 ADC measurements of the IF signal (\"samples\").\n",
      "A chirp takes 64.0 microseconds and the delay between the chirps is 400.0 microseconds.\n",
      "With a total frame duration of 29.696 milliseconds and a delay of 50.0 milliseconds between the frame we get a frame rate of 12.547681188516362 radar frames per second.\n"
     ]
    }
   ],
   "source": [
    "## Run this to understand the current radar settings better\n",
    "import json\n",
    "with open(config_file) as json_file:\n",
    "    c = json.load(json_file)[\"device_config\"][\"fmcw_single_shape\"]\n",
    "    chirp_duration = c[\"num_samples_per_chirp\"]/c['sample_rate_Hz']\n",
    "    frame_duration = (chirp_duration + c['chirp_repetition_time_s']) * c['num_chirps_per_frame']\n",
    "    print(\"With the current configuration, the radar will send out \" + str(c['num_chirps_per_frame']) + \\\n",
    "          ' signals with varying frequency (\"chirps\") between ' + str(c['start_frequency_Hz']/1e9) + \" GHz and \" + \\\n",
    "          str(c['end_frequency_Hz']/1e9) + \" GHz.\")\n",
    "    print('Each chirp will consist of ' + str(c[\"num_samples_per_chirp\"]) + ' ADC measurements of the IF signal (\"samples\").')\n",
    "    print('A chirp takes ' + str(chirp_duration*1e6) + ' microseconds and the delay between the chirps is ' + str(c['chirp_repetition_time_s']*1e6) +' microseconds.')\n",
    "    print('With a total frame duration of ' + str(frame_duration*1e3) + ' milliseconds and a delay of ' + str(c['frame_repetition_time_s']*1e3) + ' milliseconds between the frame we get a frame rate of ' + str(1/(frame_duration + c['frame_repetition_time_s'])) + ' radar frames per second.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### the next code block initiliaze the radar with set configuration and loop through the continuous frames; when it  reaches desired number of frames, we process it to get the range-doppler information out of it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "raw_data    = []\n",
    "\n",
    "with RadarIfxAvian(config_file) as device:                             # Initialize the radar with configurations\n",
    "    \n",
    "    for i_frame, frame in enumerate(device):                           # Loop through the frames coming from the radar\n",
    "        \n",
    "        raw_data.append(np.squeeze(frame['radar'].data/(4095.0)))      # Dividing by 4095.0 to scale the data\n",
    "        if(i_frame == number_of_frames-1):\n",
    "            data = np.asarray(raw_data)\n",
    "            range_doppler_map = processing.processing_rangeDopplerData(data)\n",
    "            #del data\n",
    "            break      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save('ed16_raw_data_c3',raw_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#np.save('data',data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "data00 = np.load('acquisizioni_nave/nave_raw_data_c0e0.npy')\n",
    "data00 = np.asarray(data00)\n",
    "rdm00 = processing.processing_rangeDopplerData(data00)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1000, 3, 64, 128)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(1000, 3, 64, 64)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(data00.shape)\n",
    "range_doppler_map.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "data01 = np.load('acquisizioni_nave/nave_raw_data_c0e1.npy')\n",
    "data01 = np.asarray(data01)\n",
    "rdm01 = processing.processing_rangeDopplerData(data01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "data02 = np.load('acquisizioni_nave/nave_raw_data_c0e2.npy')\n",
    "data02 = np.asarray(data02)\n",
    "rdm02 = processing.processing_rangeDopplerData(data02)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "data10 = np.load('acquisizioni_nave/nave_raw_data_c1e0.npy')\n",
    "data10 = np.asarray(data10)\n",
    "rdm10 = processing.processing_rangeDopplerData(data10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "data11 = np.load('acquisizioni_nave/nave_raw_data_c1e1.npy')\n",
    "data11 = np.asarray(data11)\n",
    "rdm11 = processing.processing_rangeDopplerData(data11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "data12 = np.load('acquisizioni_nave/nave_raw_data_c1e2.npy')\n",
    "data12 = np.asarray(data12)\n",
    "rdm12 = processing.processing_rangeDopplerData(data12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "data2 = np.load('acquisizioni_nave/nave_raw_data_c2.npy')\n",
    "data2 = np.asarray(data2)\n",
    "rdm2 = processing.processing_rangeDopplerData(data2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "data3 = np.load('acquisizioni_nave/nave_raw_data_c3.npy')\n",
    "data3 = np.asarray(data3)\n",
    "rdm3 = processing.processing_rangeDopplerData(data3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Note: There is a function to get range_data called \"processing_rangeData\" which will be usefull to detect the movements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The shape of the radar data depends on the radar settings.\n",
    "# The different dimensions of the shape are (frame_index, receiver_index, chirp_index, sample_index).\n",
    "\n",
    "print(\"(frame_index, receiver_index, chirp_index, sample_index)\")\n",
    "print(data.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Noi acquisiamo 1000 frame per 3 canali, ogni frame è costituito da 64 chirps e 128 samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def insert(data,target):\n",
    "    ant0=[]\n",
    "    target1=[]\n",
    "    for i in range(data.shape[0]): \n",
    "        ant0.append(data[i])\n",
    "        \n",
    "    if target ==0:\n",
    "        target1 = [target]*1000\n",
    "    elif target==1:\n",
    "        target1 = [target]*1000\n",
    "    elif target ==2:\n",
    "        target1= [target]*3000\n",
    "    elif target == 3:\n",
    "        target1 = [target]*3000\n",
    "        \n",
    "    bello=pd.DataFrame({'Tot_signal':ant0,'target':target1})\n",
    "    \n",
    "    return bello\n",
    "\n",
    "brutto = pd.concat([insert(rdm00,0),insert(rdm01,0),insert(rdm02,0),\n",
    "                    insert(rdm10,1),insert(rdm11,1),insert(rdm12,1),\n",
    "                    insert(rdm2,2),insert(rdm3,3)])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Tot_signal</th>\n",
       "      <th>target</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2995</th>\n",
       "      <td>[[[(7.66053886991358e-15+0j), (-0.051498141870...</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2996</th>\n",
       "      <td>[[[(1.8041124150158794e-14+0j), (-0.0036276538...</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2997</th>\n",
       "      <td>[[[(1.887379141862766e-14+0j), (-0.01201945236...</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2998</th>\n",
       "      <td>[[[(-1.7541523789077473e-14+0j), (0.0356028726...</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2999</th>\n",
       "      <td>[[[(-2.8199664825478976e-14+0j), (-0.020159803...</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                             Tot_signal  target\n",
       "2995  [[[(7.66053886991358e-15+0j), (-0.051498141870...       3\n",
       "2996  [[[(1.8041124150158794e-14+0j), (-0.0036276538...       3\n",
       "2997  [[[(1.887379141862766e-14+0j), (-0.01201945236...       3\n",
       "2998  [[[(-1.7541523789077473e-14+0j), (0.0356028726...       3\n",
       "2999  [[[(-2.8199664825478976e-14+0j), (-0.020159803...       3"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "brutto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "brutto.to_csv('nave_map.csv',index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axs = plot.subplots(3, 5,figsize=(15,10),sharex=True, sharey=  True)\n",
    "fig.suptitle('Range-Doppler Plot')\n",
    "\n",
    "for i in range(3):\n",
    "    for j in range(5):\n",
    "        axs[i, j].imshow(np.abs(range_doppler_map)[j,i,:,:])\n",
    "        axs[i, j].set_aspect('equal')\n",
    "\n",
    "plot.subplots_adjust(hspace=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras import Model\n",
    "from keras.layers import Dense\n",
    "\n",
    "from keras_pandas.Automater import Automater\n",
    "from keras_pandas.lib import load_titanic\n",
    "\n",
    "observations = load_titanic()\n",
    "\n",
    "# Transform the data set, using keras_pandas\n",
    "numerical_vars = ['Tot_signal']\n",
    "\n",
    "\n",
    "auto = Automater(categorical_vars=categorical_vars, numerical_vars=numerical_vars, text_vars=text_vars,\n",
    " response_var='survived')"
   ]
  }
 ],
 "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": 5
}