def doppler_resolution(self): _, bw = dsp.range_resolution( self.cfg['profiles'][0]['adcSamples'], self.cfg['profiles'][0]['adcSampleRate'] / 1000, self.cfg['profiles'][0]['freqSlopeConst'] / 1e12) return dsp.doppler_resolution( bw, start_freq_const=self.cfg['profiles'][0]['start_frequency'] / 1e9, ramp_end_time=self.cfg['profiles'][0]['rampEndTime'] * 1e6, idle_time_const=self.cfg['profiles'][0]['idle'] * 1e6, num_loops_per_frame=self.cfg['numChirps'] / len(self.cfg['chirps']), num_tx_antennas=self.cfg['numTx'])
numLoopsPerFrame = configParameters['numLoops'] numChirpsPerFrame = numTxAntennas * numLoopsPerFrame numRangeBins = numADCSamples # numDopplerBins = numLoopsPerFrame numDopplerBins = numLoopsPerFrame numAngleBins = 64 # data processing parameter numDisplaySamples = 20 range_resolution, bandwidth = dsp.range_resolution( numADCSamples, dig_out_sample_rate=configParameters['digOutSampleRate'], freq_slope_const=configParameters['freqSlopeConst']) doppler_resolution = dsp.doppler_resolution( bandwidth, start_freq_const=configParameters['startFreq'], ramp_end_time=configParameters['rampEndTime'], idle_time_const=configParameters['idleTime'], num_loops_per_frame=configParameters['numLoops'], num_tx_antennas=numTxAntennas) print( f'Range Resolution: {range_resolution}, Bandwidth: {bandwidth}, Doppler Resolution: {doppler_resolution}' ) ims = [] max_size = 0
# QOL settings loadData = True numFrames = 300 numADCSamples = 128 numTxAntennas = 3 numRxAntennas = 4 numLoopsPerFrame = 128 numChirpsPerFrame = numTxAntennas * numLoopsPerFrame numRangeBins = numADCSamples numDopplerBins = numLoopsPerFrame numAngleBins = 64 range_resolution, bandwidth = dsp.range_resolution(numADCSamples) doppler_resolution = dsp.doppler_resolution(bandwidth) plotRangeDopp = False plot2DscatterXY = False plot2DscatterXZ = False plot3Dscatter = True plotCustomPlt = False plotMakeMovie = False makeMovieTitle = "3dscatter" makeMovieDirectory = r"c://Users//Zber//Desktop//mymovie.mp4" visTrigger = plot2DscatterXY + plot2DscatterXZ + plot3Dscatter + plotRangeDopp + plotCustomPlt assert visTrigger < 2, "Can only choose to plot one type of plot at once"
def featureExtraction(folder, optPath): """ Return opt: numFrame, 3 (heatmaps), 46*46(angle bin), nLoopsPerFrame """ startTime = '' with open(folder+'adc_data_Raw_LogFile.csv') as csv_file: csv_reader = csv.reader(csv_file, delimiter=',') for row in csv_reader: if 'Capture start time' in str(row): startTimeRow = row break startTimeStr = startTimeRow[0].split(' - ')[1] timestamp = datetime.datetime.timestamp(parser.parse(startTimeStr)) timestampList = [] filename = folder + 'adc_data.bin' numFrames = 640 numADCSamples = 512 numTxAntennas = 2 numRxAntennas = 4 numLoopsPerFrame = 76 numChirpsPerFrame = numTxAntennas * numLoopsPerFrame BINS_PROCESSED = 55 ANGLE_RES = 1 ANGLE_RANGE = 70 ANGLE_BINS = (ANGLE_RANGE * 2) // ANGLE_RES + 1 reso = dsp.range_resolution(numADCSamples, dig_out_sample_rate=6000, freq_slope_const=39.010) reso = round(reso[0], 4) adc_data = np.fromfile(filename, dtype=np.uint16) # (1) Load Data if adc_data.shape[0]<398458880: padSize = 398458880 - adc_data.shape[0] print("padded size: ", padSize) adc_data = np.pad(adc_data, padSize)[padSize:] adc_data = adc_data.reshape(numFrames, -1) adc_data = np.apply_along_axis(DCA1000.organize, 1, adc_data, num_chirps=numChirpsPerFrame, num_rx=numRxAntennas, num_samples=numADCSamples) heatmaps = np.zeros((adc_data.shape[0], ANGLE_BINS, ANGLE_BINS), dtype = 'float32') numVirAntHori = 3 numVirAntVer = 4 # (2) Start DSP processing num_vec_4va, steering_vec_4va = dsp.gen_steering_vec(ANGLE_RANGE, ANGLE_RES, numVirAntVer) num_vec_3va, steering_vec_3va = dsp.gen_steering_vec(ANGLE_RANGE, ANGLE_RES, numVirAntHori) # (3) Process each frame for i, frame in enumerate(adc_data): timestamp+=0.033 timestampList.append(timestamp) range_azimuth = np.zeros((ANGLE_BINS, BINS_PROCESSED-10)) range_azimuth2 = np.zeros((ANGLE_BINS, BINS_PROCESSED-10)) range_elevation = np.zeros((ANGLE_BINS, BINS_PROCESSED-10)) # Range Processing radar_cube = dsp.range_processing(frame, window_type_1d=Window.BLACKMAN) """ (Capon Beamformer) """ # --- static clutter removal / normalize mean = radar_cube.mean(0) radar_cube = radar_cube - mean # --- capon beamforming beamWeights_azimuth = np.zeros((numVirAntHori, BINS_PROCESSED), dtype=np.complex_) beamWeights_azimuth2 = np.zeros((numVirAntHori, BINS_PROCESSED), dtype=np.complex_) beamWeights_elevation = np.zeros((numVirAntVer, BINS_PROCESSED), dtype=np.complex_) # Separate TX, rx 1234, vrx1234 radar_cube = np.concatenate((radar_cube[0::2, ...], radar_cube[1::2, ...]), axis=1) # Note that when replacing with generic doppler estimation functions, radarCube is interleaved and # has doppler at the last dimension. # Range bin processed for j in range(10,BINS_PROCESSED): range_azimuth[:, j-10], beamWeights_azimuth[:, j-10] = dsp.aoa_capon( radar_cube[:, 1:4 , j-10].T, steering_vec_3va, magnitude=True) range_azimuth2[:, j-10], beamWeights_azimuth2[:, j-10] = dsp.aoa_capon( radar_cube[:, 5:8 , j-10].T, steering_vec_3va, magnitude=True) range_elevation[:, j-10], beamWeights_elevation[:, j-10] = dsp.aoa_capon( radar_cube[:, [0,4,1,5] , j-10].T, steering_vec_4va, magnitude=True) # normalize prescale_factor = 10000000 range_azimuth = scale(range_azimuth/prescale_factor, axis = 1) range_azimuth2 = scale(range_azimuth2/prescale_factor, axis = 1) range_elevation = scale(range_elevation/prescale_factor, axis = 1) range_azimuth = resize(range_azimuth, (ANGLE_BINS, ANGLE_BINS/3)) range_azimuth2 = resize(range_azimuth2, (ANGLE_BINS, ANGLE_BINS/3)) range_elevation = resize(range_elevation, (ANGLE_BINS, ANGLE_BINS/3)) heatmaps[i,:,:] = np.concatenate((range_azimuth, range_azimuth2, range_elevation), axis = 1) # opt heatmaps=heatmaps.astype('float32') if np.isnan(heatmaps).sum() + np.isinf(heatmaps).sum() > 0: print('dtype: ', heatmaps.dtype, ', has NAN or INF error') else: print('dtype: ', heatmaps.dtype) if optPath != '': # if not os.path.isdir(optPath + '//'): # os.mkdir(optPath + '//') np.savez(optPath+'.npz', heatmaps=heatmaps, timestampList=timestampList) return heatmaps, np.array(timestampList), reso
# Important Radar Scan Constants # Using Radar: Texas Instruments 1843 num_frames = 500 num_adc_samples = 128 num_tx_antennas = 3 num_rx_antennas = 4 num_loops_per_frame = 128 num_chirps_per_frame = num_tx_antennas * num_loops_per_frame num_range_bins = num_adc_samples num_doppler_bins = num_loops_per_frame num_angle_bins = 64 chirp_period = 0.06 range_resolution, bandwidth = dsp.range_resolution(num_adc_samples) doppler_resolution = dsp.doppler_resolution(bandwidth) load_data_flag = True accumulate_flag = True logGabor_flag = False plot_range_doppler_flag = False if __name__ == '__main__': if load_data_flag: # (1) Reading in adc data adc_data = np.fromfile('./data/processed/uDoppler1.bin', dtype=np.int16) # adc_data = np.fromfile('./scripts/data/adc_data.bin', dtype=np.int16)
def generate_spectrum_from_RDC(filename, numFrames=500, numADCSamples=128, numTxAntennas=3, numRxAntennas=4, numLoopsPerFrame=128, numAngleBins=64, chirpPeriod=0.06, logGabor=False, accumulate=True, save_full=False): numChirpsPerFrame = numTxAntennas * numLoopsPerFrame # ============================================================================= # numADCSamples = number of range bins # numLoopsPerFrame = number of doppler bins # ============================================================================= range_resolution, bandwidth = dsp.range_resolution(numADCSamples) doppler_resolution = dsp.doppler_resolution(bandwidth) if filename[-4:] != '.bin': filename += '.bin' adc_data = np.fromfile(filename, dtype=np.int16) adc_data = adc_data.reshape(numFrames, -1) adc_data = np.apply_along_axis(DCA1000.organize, 1, adc_data, num_chirps=numChirpsPerFrame, num_rx=numRxAntennas, num_samples=numADCSamples) print("Data Loaded!") dataCube = adc_data micro_doppler_data = np.zeros((numFrames, numLoopsPerFrame, numADCSamples), dtype=np.float64) theta_data = np.zeros((numFrames, numLoopsPerFrame, numTxAntennas * numRxAntennas, numADCSamples), dtype=np.complex) for i, frame in enumerate(dataCube): # (2) Range Processing from mmwave.dsp.utils import Window radar_cube = dsp.range_processing(frame, window_type_1d=Window.BLACKMAN) assert radar_cube.shape == ( numChirpsPerFrame, numRxAntennas, numADCSamples), "[ERROR] Radar cube is not the correct shape!" # (3) Doppler Processing det_matrix, theta_data[i] = dsp.doppler_processing( radar_cube, num_tx_antennas=3, clutter_removal_enabled=True, window_type_2d=Window.HAMMING) # --- Shifts & Store det_matrix_vis = np.fft.fftshift(det_matrix, axes=1) micro_doppler_data[i, :, :] = det_matrix_vis # Data should now be ready. Needs to be in micro_doppler_data, a 3D-numpy array with shape [numDoppler, numRanges, numFrames] # LOG GABOR if logGabor: if accumulate: image = micro_doppler_data.sum(axis=1).T else: image = micro_doppler_data.T from LogGabor import LogGabor import holoviews as hv lg = LogGabor("default_param.py") lg.set_size(image) lg.pe.datapath = 'database/' image = lg.normalize(image, center=True) # display input image # hv.Image(image) # display log gabor'd image image = lg.whitening(image) * lg.mask hv.Image(image) uDoppler = image elif accumulate: uDoppler = micro_doppler_data.sum(axis=1).T else: uDoppler = micro_doppler_data.T if save_full: return range_resolution, doppler_resolution, uDoppler, theta_data else: return range_resolution, doppler_resolution, uDoppler
import matplotlib.pyplot as plt import numpy as np from mmwave import dsp # Radar specific parameters from mmwave.dsp import Window from radar_utils.data_loader import load_file from dsp_utils import extract_phases from etc.config_1 import adc_samples, NUM_FRAMES from filter_params import dist_range_bottom, dist_range_top, all_data, freq_range_top, freq_range_bottom, \ slow_sample_rate, time_filter_bottom, time_filter_top from plot_utils import plot_named_list, plot_range_maps from signal_generation import table fig = plt.figure() range_res, _ = dsp.range_resolution(200, 4000, 70) freq_res = 20 / 1000 # 20 Hz / 1000 samples ranges = np.arange(adc_samples) * range_res range_mask = (dist_range_bottom < ranges) & (ranges < dist_range_top) ranges_filtered = ranges[range_mask] frequencies = np.arange(0, NUM_FRAMES / 2) * freq_res frequency_mask = (frequencies > freq_range_bottom) & (frequencies < freq_range_top) frequencies_filtered = frequencies[frequency_mask] times = np.arange(0, NUM_FRAMES) * slow_sample_rate time_mask = (time_filter_bottom < times) & (times < time_filter_top) times_filtered = times[time_mask] keyword = "s" data_set = [
def range_resolution(self): range_res, bw = dsp.range_resolution( self.cfg['profiles'][0]['adcSamples'], self.cfg['profiles'][0]['adcSampleRate'] / 1000, self.cfg['profiles'][0]['freqSlopeConst'] / 1e12) return range_res
import numpy as np # Radar specific parameters from mmwave.dsp import range_resolution, doppler_resolution from etc.config_1 import NUM_CHIRPS, NUM_ADC_SAMPLES, sample_rate, freq_slope, adc_samples, \ start_freq, idle_time, ramp_end_time # Data specific parameters # DSP processing parameters # Data sampling configuration # Range and Velocity resolution range_res, band_width = range_resolution(NUM_ADC_SAMPLES, sample_rate, freq_slope) # range_res = RANGE_RESOLUTION print(f'Range Resolution: {range_res} [meters]') velocity_res = doppler_resolution(band_width, start_freq, ramp_end_time, idle_time, NUM_CHIRPS, 1) print(f'Velocity Resolution: {velocity_res} [meters/second]') # Apply the range resolution factor to the range indices ranges = np.arange(adc_samples) * range_res def load_file(file_path, radar_config=None, discard_rx=True): adc_data = np.fromfile(file_path, dtype=np.uint16) adc_data = adc_data.reshape(NUM_FRAMES, -1) all_data = np.apply_along_axis(DCA1000.organize, 1,