def reset(device_name):
mc = ModuleConnector(device_name)
XEP = mc.get_xep()
XEP.module_reset()
mc.close()
sleep(3)
def xep_setup(device_name, baseband):
reset(device_name)
mc = ModuleConnector(device_name)
app = mc.get_x4m300()
try:
app.set_sensor_mode(0x13, 0) # Make sure no profile is running.
except RuntimeError:
pass
try:
app.set_sensor_mode(0x12, 0) # Manual mode.
except RuntimeError:
pass
xep = mc.get_xep()
xep.mc = mc
# Set DAC range
xep.x4driver_set_dac_min(949)
xep.x4driver_set_dac_max(1100)
# Set integration
xep.x4driver_set_iterations(16)
xep.x4driver_set_pulses_per_step(10)
xep.x4driver_set_downconversion(int(baseband))
# Set detection range
xep.x4driver_set_frame_area(0, 9.0)
return xep
def reset(self, device_name):
mc = ModuleConnector(device_name, 9)
r = mc.get_xep()
r.module_reset()
mc.close()
time.sleep(3)
print('device_name')
def xep_setup(device_name, baseband):
reset(device_name)
mc = ModuleConnector(device_name)
# Assume an X4M300/X4M200 module and try to enter XEP mode
app = mc.get_x4m300()
# Stop running application and set module in manual mode.
try:
app.set_sensor_mode(0x13, 0) # Make sure no profile is running.
except RuntimeError:
# Profile not running, OK
pass
try:
app.set_sensor_mode(0x12, 0) # Manual mode.
except RuntimeError:
# Sensor already stopped, OK
pass
xep = mc.get_xep()
xep.mc = mc
# Set DAC range
xep.x4driver_set_dac_min(949)
xep.x4driver_set_dac_max(1100)
# Set integration
xep.x4driver_set_iterations(16)
xep.x4driver_set_pulses_per_step(10)
xep.x4driver_set_downconversion(int(baseband))
# Set detection range
xep.x4driver_set_frame_area(0, 9.0)
return xep
def reset(device_name):
from time import sleep
mc = ModuleConnector(device_name)
r = mc.get_xep()
r.module_reset()
mc.close()
sleep(3)
def main():
parser = ArgumentParser()
parser.add_argument("-d",
"--device",
dest="device_name",
help="device file to use",
metavar="FILE")
parser.add_argument("-b",
"--baseband",
action="store_true",
default=True,
dest="baseband",
help="Enable baseband output")
parser.add_argument("-rf",
"--radiofrequency",
action="store_false",
dest="baseband",
help="Enable rf output")
parser.add_argument("-n",
"--framesnumber",
metavar="NUMBER",
type=int,
default=20,
dest="frames_number",
help="Decide how mange frames shown on plotting")
parser.add_argument("-r",
"--record",
action="store_true",
default=False,
dest="record",
help="Enable recording")
parser.add_argument("-f",
"--file",
dest="meta_filename",
metavar="FILE",
help="meta file from recording")
args = parser.parse_args()
if not args.meta_filename:
if args.device_name:
device_name = args.device_name
else:
try:
device_name = auto()[0]
except:
print("Fail to find serial port, please specify it by use -d!")
raise
print_module_info(device_name)
xep = configure_x4(device_name, args.record, args.baseband,
x4_par_settings)
else:
player = start_player(meta_filename=args.meta_filename)
mc = ModuleConnector(player, log_level=0)
xep = mc.get_xep()
plot_radar_raw_data_message(xep,
baseband=args.baseband,
frames_number=args.frames_number)
def set_certification_mode(device_name, mode_code):
mc = ModuleConnector(device_name)
xep = mc.get_xep()
app = mc.get_x4m300()
data = mcw.ucVector()
app.system_run_test(mode_code, data)
print("Set Mode:0x%X" % mode_code)
xep.module_reset()
mc.close()
def main():
module = auto('x4')
mc = ModuleConnector(module[0])
xep = mc.get_xep()
regmap = X4(xep)
# Use regmap object to access registers, for example to set tx_power
print("Setting TX power to 1")
regmap.tx_power = 1
print("TX power is now %d" % regmap.tx_power)
# In an interactive session use tab-completion to get a list of
# available registers
return 0
def main():
parser = OptionParser()
parser.add_option(
"-d",
"--device",
dest="device_name",
help="device file to use",
metavar="FILE")
parser.add_option(
"-b",
"--baseband",
action="store_true",
default=False,
dest="baseband",
help="Enable baseband output, rf data is default")
parser.add_option(
"-r",
"--record",
action="store_true",
default=False,
dest="record",
help="Enable recording")
parser.add_option(
"-f",
"--file",
dest="meta_filename",
metavar="FILE",
help="meta file from recording")
(options, args) = parser.parse_args()
if not options.meta_filename:
if options.device_name:
device_name = options.device_name
else:
try:
device_name = auto()[0]
except:
print("Fail to find serial port, please specify it by use -d!")
raise
print_module_info(device_name)
xep = configure_x4(device_name,
options.record, options.baseband, x4_par_settings)
else:
player = start_player(meta_filename=options.meta_filename)
mc = ModuleConnector(player, log_level=0)
xep = mc.get_xep()
plot_radar_raw_data_message(xep, baseband=options.baseband)
def display_information(device_name):
print("trying to read information from module")
log_level = 1
if device_name == "auto":
devices = auto()
if len(devices) == 0:
print("Failed to find COM port matching known vid and pids")
return 1
device_name = devices[0]
mc = ModuleConnector(device_name, log_level)
xep = mc.get_xep()
sleep(1) # Allow for MC to read waiting messages from module.
print(xep.get_system_info(XTID_SSIC_FIRMWAREID))
print(xep.get_system_info(XTID_SSIC_VERSION))
print(xep.get_system_info(XTID_SSIC_BUILD))
mc.close()
def print_module_info(device_name):
# Stop running application and set module in manual mode.
mc = ModuleConnector(device_name)
app = mc.get_x4m200()
# Stop running application and set module in manual mode.
try:
app.set_sensor_mode(XTS_SM_STOP, 0) # Make sure no profile is running.
except RuntimeError:
# Profile not running, OK
pass
try:
app.set_sensor_mode(XTS_SM_MANUAL, 0) # Manual mode.
except RuntimeError:
# Maybe already running at X4driver level
pass
xep = mc.get_xep()
pong = xep.ping()
print("")
print("********** XeThru Module Information **********")
print("")
print('Received pong= ', hex(pong) + ' connection build!')
print('FirmWareID = ', xep.get_system_info(XTID_SSIC_FIRMWAREID))
print('Version = ', xep.get_system_info(XTID_SSIC_VERSION))
print('Build = ', xep.get_system_info(XTID_SSIC_BUILD))
print('VersionList = ', xep.get_system_info(XTID_SSIC_VERSIONLIST))
# Following three item only supported by XeThru Sensor, e.g.X4M200, X4M300. X4M03 does not these information and will feedback error message when read.
try:
OrderCode = "X4Mxx"
OrderCode = xep.get_system_info(XTID_SSIC_ORDERCODE)
print('OrderCode = ', OrderCode)
print('ItemNumber = ', xep.get_system_info(XTID_SSIC_ITEMNUMBER))
print('SerialNumber = ', xep.get_system_info(XTID_SSIC_SERIALNUMBER))
except:
# This is not a sensor but a development kit running XEP.
pass
# Uncomment following line to enable print X4 setting from XeThru module
# print_x4_settings(xep)
mc.close()
return OrderCode
def try_xep(device_name):
log_level = 0
mc = ModuleConnector(device_name, log_level)
x4m300 = mc.get_x4m300()
# we have to go to manual mode
x4m300.set_sensor_mode(XTS_SM_STOP, 0)
x4m300.set_sensor_mode(XTS_SM_MANUAL, 0)
xep = mc.get_xep()
pong = xep.ping()
print("Received pong:", hex(pong))
print('ItemNumber =', xep.get_system_info(XTID_SSIC_ITEMNUMBER))
print('OrderCode =', xep.get_system_info(XTID_SSIC_ORDERCODE))
print('FirmWareID =', xep.get_system_info(XTID_SSIC_FIRMWAREID))
print('Version =', xep.get_system_info(XTID_SSIC_VERSION))
print('Build =', xep.get_system_info(XTID_SSIC_BUILD))
print('SerialNumber =', xep.get_system_info(XTID_SSIC_SERIALNUMBER))
print('VersionList =', xep.get_system_info(XTID_SSIC_VERSIONLIST))
# inti x4driver
xep.x4driver_init()
# Set enable pin
xep.x4driver_set_enable(1)
# Set iterations
xep.x4driver_set_iterations(16)
# Set pulses per step
xep.x4driver_set_pulses_per_step(256)
# Set dac min
xep.x4driver_set_dac_min(949)
# Set dac max
xep.x4driver_set_dac_max(1100)
# Set TX power
xep.x4driver_set_tx_power(2)
# Enable downconversion
xep.x4driver_set_downconversion(1)
# Set frame area offset
xep.x4driver_set_frame_area_offset(0.18)
offset = xep.x4driver_get_frame_area_offset()
print('x4driver_get_frame_area_offset returned: ', offset)
# Set frame area
xep.x4driver_set_frame_area(2, 6)
frame_area = xep.x4driver_get_frame_area()
print('x4driver_get_frame_area returned: [', frame_area.start, ', ',
frame_area.end, ']')
# Set TX center freq
xep.x4driver_set_tx_center_frequency(3)
# Set PRFdiv
xep.x4driver_set_prf_div(16)
prf_div = xep.x4driver_get_prf_div()
print('x4driver_get_prf_div returned: ', prf_div)
# Start streaming
xep.x4driver_set_fps(20)
fps = xep.x4driver_get_fps()
print('xep_x4driver_get_fps returned: ', fps)
# Wait 5 sec.
time.sleep(5)
# Stop streaming
xep.x4driver_set_fps(0)
# Read data float if available.
if xep.peek_message_data_float() > 0:
data_float = xep.read_message_data_float()
else:
print('No data float messages available.')
# Reset module
xep.module_reset()
def reset(self, device_name):
mc = ModuleConnector(device_name)
r = mc.get_xep()
r.module_reset()
mc.close()
sleep(3)
class CollectionThreadX4(threading.Thread):
def __init__(self,
threadID,
name,
radarBuffer,
stopEvent,
radarSettings,
baseband=False,
fs=17,
radarPort='/dev/tty.usbmodem14301',
simulate=False,
filePaths=None,
nonRealTimeMode=False,
resumeEvent=None):
threading.Thread.__init__(self)
self.name = name
self.threadID = threadID
self.radarBuffer = radarBuffer
self.stopEvent = stopEvent
self.resumeEvent = resumeEvent
self.nonRealTimeMode = nonRealTimeMode
self.radarPort = radarPort
self.radarSettings = radarSettings
self.simulate = simulate
self.filePaths = filePaths
self.fs = fs
self.baseband = baseband
print('Collection thread initialized')
def run(self):
global radarDataQ
if self.simulate:
prevTStamp = 0
for file in self.filePaths:
print(('Opening file: ', file))
with open(file) as csvFile:
thisFileData = []
csvReader = csv.reader(csvFile)
times = []
for row in csvReader:
# print int(float(row[0]))
times.append(int(float(row[0])))
# print row
row = [value.replace('i', 'j') for value in row]
# row = list(imap(replace('i','j'),row))
row = list(map(complex, row))
# print row
# row = list(imap(int, row))
thisFileData.append(row)
if self.stopEvent.is_set():
break
thisFileDataNP = np.array(thisFileData, dtype=complex)
# times = list(imap(int,thisFileDataNP[:,0]))
# print times
prevTStamp = times[0] #prevTStamp is 0 for multiple files
fileitr = 0
for timestamp in times:
thisSleep = (timestamp - prevTStamp) / 1000
# print('Sleeping %f seconds'%thisSleep)
time.sleep(thisSleep)
self.radarBuffer.put(list(thisFileData[fileitr]))
fileitr += 1
prevTStamp = timestamp
if self.nonRealTimeMode:
if not self.resumeEvent.is_set():
print('Pausing till user response')
self.resumeEvent.wait()
print('Resuming')
if self.stopEvent.is_set():
break
if self.stopEvent.is_set():
break
print('Simulation complete')
else:
print('Initializing radar')
self.reset(self.radarPort)
self.mc = ModuleConnector(self.radarPort)
self.radarObject = self.mc.get_xep()
# Set DAC range
try:
self.radarObject.x4driver_set_dac_min(
self.radarSettings['DACMin'])
self.radarObject.x4driver_set_dac_max(
self.radarSettings['DACMax'])
# Set integration
self.radarObject.x4driver_set_iterations(
self.radarSettings['Iterations'])
self.radarObject.x4driver_set_pulses_per_step(
self.radarSettings['PulsesPerStep'])
self.radarObject.x4driver_set_frame_area(
self.radarSettings['FrameStart'],
self.radarSettings['FrameStop'])
except RuntimeError as e:
print('error setting up radar')
self.radarBuffer.put('setup_error')
# self.radarObject.x4driver_set_dac_min(self.radarSettings['DACMin'])
# self.radarObject.x4driver_set_dac_max(self.radarSettings['DACMax'])
#
# # Set integration
# self.radarObject.x4driver_set_iterations(self.radarSettings['Iterations'])
# self.radarObject.x4driver_set_pulses_per_step(self.radarSettings['PulsesPerStep'])
# self.radarObject.x4driver_set_frame_area(self.radarSettings['FrameStart'],self.radarSettings['FrameStop'])
if self.baseband:
self.radarObject.x4driver_set_downconversion(1)
self.radarObject.x4driver_set_fps(self.fs)
frame = self.read_frame()
if self.baseband:
frame = abs(frame)
self.clear_buffer()
startTime = time.time()
print((self.radarObject.get_system_info(0x07)))
print('power {0}'.format(self.radarObject.x4driver_get_tx_power()))
print('Starting radar data collection')
while not self.stopEvent.is_set():
currentTime = time.time()
radarFrame = self.read_frame()
self.radarBuffer.put([int((currentTime - startTime) * 1000)] +
list(radarFrame))
self.radarObject.x4driver_set_fps(0) # stop the radar
def reset(self, device_name):
mc = ModuleConnector(device_name, 9)
r = mc.get_xep()
r.module_reset()
mc.close()
time.sleep(3)
print('device_name')
def read_frame(self):
"""Gets frame data from module"""
d = self.radarObject.read_message_data_float()
frame = np.array(d.data)
# Convert the resulting frame to a complex array if downconversion is enabled
if self.baseband:
n = len(frame)
# print type(n // 2)
frame = frame[:n // 2] + 1j * frame[n // 2:]
return frame
def clear_buffer(self):
"""Clears the frame buffer"""
while self.radarObject.peek_message_data_float():
_ = self.radarObject.read_message_data_float()
def reset(device_name):
mc = ModuleConnector(device_name)
xep = mc.get_xep()
xep.module_reset()
mc.close()
time.sleep(1)
class CollectionThreadX4MP(multiprocessing.Process):
def __init__(self,
threadID,
name,
stopEvent,
radarSettings,
baseband=False,
fs=17,
radarPort='/dev/ttyACM0',
dataQueue=None):
multiprocessing.Process.__init__(self)
self.name = name
self.stopEvent = stopEvent
self.radarDataQ = dataQueue
self.radarPort = radarPort
self.radarSettings = radarSettings
self.fs = fs
self.radarPort = radarPort
self.baseband = baseband
print('Collection thread initialized')
def run(self):
print('Initializing radar')
self.reset(self.radarPort)
self.mc = ModuleConnector(self.radarPort)
self.radarObject = self.mc.get_xep()
# Set DAC range
self.radarObject.x4driver_set_dac_min(self.radarSettings['DACMin'])
self.radarObject.x4driver_set_dac_max(self.radarSettings['DACMax'])
# Set integration
self.radarObject.x4driver_set_iterations(
self.radarSettings['Iterations'])
self.radarObject.x4driver_set_pulses_per_step(
self.radarSettings['PulsesPerStep'])
self.radarObject.x4driver_set_frame_area(
self.radarSettings['FrameStart'], self.radarSettings['FrameStop'])
if self.baseband:
self.radarObject.x4driver_set_downconversion(1)
self.radarObject.x4driver_set_fps(self.fs)
frame = self.read_frame()
if self.baseband:
frame = abs(frame)
self.clear_buffer()
startTime = time.time()
print((self.radarObject.get_system_info(0x07)))
print('Starting radar data collection')
while True:
# print ('----------------')
currentTime = time.time()
radarFrame = self.read_frame()
rdDataRowstr = []
for i in range(len(radarFrame)):
rdDataRowstr.append(
str(radarFrame[i]).replace('(', '').replace(')', ''))
self.radarDataQ.put([currentTime] + list(rdDataRowstr))
self.radarObject.x4driver_set_fps(0) # stop the radar
def reset(self, device_name):
mc = ModuleConnector(device_name)
r = mc.get_xep()
r.module_reset()
mc.close()
time.sleep(3)
def read_frame(self):
"""Gets frame data from module"""
d = self.radarObject.read_message_data_float()
frame = np.array(d.data)
# print len(frame)
# print frame
# Convert the resulting frame to a complex array if downconversion is enabled
if self.baseband:
n = len(frame)
# print type(n // 2)
frame = frame[:n // 2] + 1j * frame[n // 2:]
return frame
def clear_buffer(self):
"""Clears the frame buffer"""
while self.radarObject.peek_message_data_float():
_ = self.radarObject.read_message_data_float()
def simple_xep_plot(device_name, bb=False):
FPS = 10
reset(device_name)
mc = ModuleConnector(device_name)
# Assume an X4M300/X4M200 module and try to enter XEP mode
app = mc.get_x4m300()
# Stop running application and set module in manual mode.
try:
app.set_sensor_mode(0x13, 0) # Make sure no profile is running.
except RuntimeError:
# Profile not running, OK
pass
try:
app.set_sensor_mode(0x12, 0) # Manual mode.
except RuntimeError:
# Sensor already stopped, OK
pass
r = mc.get_xep()
# Set DAC range
r.x4driver_set_dac_min(900)
r.x4driver_set_dac_max(1150)
# Set integration
r.x4driver_set_iterations(16)
r.x4driver_set_pulses_per_step(26)
if bb:
r.x4driver_set_downconversion(1)
else:
r.x4driver_set_downconversion(0)
# Start streaming of data
r.x4driver_set_fps(FPS)
def clear_buffer():
"""Clears the frame buffer"""
while r.peek_message_data_float():
_ = r.read_message_data_float()
def read_frame():
"""Gets frame data from module"""
d = r.read_message_data_float()
frame = np.array(d.data)
# Convert the resulting frame to a complex array if downconversion is enabled
if bb:
n = len(frame)
frame = frame[:n / 2] + 1j * frame[n / 2:]
return frame
def animate(i):
if bb:
line.set_ydata(abs(read_frame())) # update the data
else:
line.set_ydata(read_frame()) # update the data
return line,
fig = plt.figure()
fig.suptitle("BreathingDetection_V1 10 FPS")
ax = fig.add_subplot(1, 1, 1)
frame = read_frame()
if bb:
frame = abs(frame)
line, = ax.plot(frame)
clear_buffer()
ani = FuncAnimation(fig, animate, interval=FPS)
#plt.margins(0,0)
plt.xlim(50, 200)
plt.ylim(-0.07, 0.07)
#print(frame)
plt.show()
# Stop streaming of data
r.x4driver_set_fps(0)