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 start_playback(meta_filename, depth):
print("start playback from: {}, depth: {}".format(meta_filename, depth))
##! [Typical usage]
player = DataPlayer(meta_filename, depth)
mc = ModuleConnector(player, log_level=0)
# Get read-only interface and receive telegrams / binary packets from recording
x4m300 = mc.get_x4m300()
# Control output
player.set_filter(DataType.BasebandIqDataType | DataType.PresenceSingleDataType);
player.play()
# ...
player.pause();
# ...
player.set_playback_rate(2.0);
##! [Typical usage]
player.set_playback_rate(1.0);
player.set_loop_mode_enabled(True);
player.play();
try:
while True:
if x4m300.peek_message_baseband_iq():
data = x4m300.read_message_baseband_iq()
print("received baseband iq data, frame counter: {}".format(data.frame_counter))
if x4m300.peek_message_presence_single():
data = x4m300.read_message_presence_single()
print("received presence single data, frame counter: {}".format(data.frame_counter))
time.sleep(0.02) # Sleep 20 ms
except (KeyboardInterrupt, SystemExit):
del mc
raise
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(device_name):
mc = ModuleConnector(device_name)
XEP = mc.get_xep()
XEP.module_reset()
mc.close()
sleep(3)
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 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 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 main():
parser = ArgumentParser()
parser.add_argument("-d",
"--device",
dest="device_name",
help="device file to use",
metavar="FILE")
parser.add_argument(
"-t",
"--data_type",
dest="data_type",
default="iq",
help="Data to get. iq or ap", # only one option can be choose
metavar="TYPE")
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
xt_sensor = configure_sensor_bb_output(device_name, args.record,
args.data_type)
else:
player = start_player(meta_filename=args.meta_filename)
mc = ModuleConnector(player, log_level=0)
xt_sensor = mc.get_x4m200()
plot_sensor_bb_message(xt_sensor, args.data_type)
def __init__(self, usb_port):
'''
Parser for streaming data from Xethru X4M300 presence sensor from Novelda.
:param usb_port: String
'''
self.usb_port = usb_port
self.mc = ModuleConnector(usb_port)
self.x4m300 = self.mc.get_x4m300()
self.x4m300.set_sensor_mode(XTID_SM_STOP, 0)
self.x4m300.load_profile(XTS_ID_APP_PRESENCE_2)
self.x4m300.set_output_control(XTS_ID_PRESENCE_SINGLE, 1)
self.x4m300.set_output_control(XTS_ID_BASEBAND_IQ, 1)
self.x4m300.set_sensor_mode(XTID_SM_RUN, 0)
def goto_bootloader(device_name):
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]
log_level = 1
mc = ModuleConnector(device_name, log_level)
x4m300 = mc.get_x4m300()
sleep(1) # Allow for MC to read waiting messages from module.
try:
# if this fails it will throw
x4m300.start_bootloader()
except:
print("Could not go to bootloader, may be there already.")
mc.close()
def record_sleep(device_name):
directory = "."
# Reset module
mc = ModuleConnector(device_name)
x4m200 = mc.get_x4m200()
x4m200.module_reset()
mc.close()
sleep(3)
# Assume an X4M300/X4M200 module and try to enter XEP mode
mc = ModuleConnector(device_name)
x4m200 = mc.get_x4m200()
recorder = mc.get_data_recorder()
recorder = mc.get_data_recorder()
recorder.subscribe_to_file_available(pymoduleconnector.AllDataTypes,
on_file_available)
recorder.subscribe_to_meta_file_available(on_meta_file_available)
recorder.start_recording(
DataType.BasebandApDataType | DataType.SleepDataType, directory)
# Stop running application and set module in manual mode.
try:
x4m200.set_sensor_mode(0x01, 0) # Make sure no profile is running
except RuntimeError:
# Profile not running, OK
pass
# Load x4m200 respiration detection profile
x4m200.load_profile(0x47fabeba)
try:
x4m200.set_sensor_mode(0x01, 0) #RUN mode
except RuntimeError:
# Sensor already stopped, OK
pass
x4m200.set_output_control(0x610a3b00, 1)
while True:
rdata = x4m200.read_message_respiration_sleep()
print(
"Frame: {} RPM: {} Distance: {} Movement Slow: {} Movement Fast: {}"
.format(rdata.frame_counter, rdata.respiration_rate,
rdata.distance, rdata.movement_slow, rdata.movement_fast))
sleep(0.2)
def run(self):#运行一个线程
xep_operate = my_xep.Connect_xep(self.fps,self.dac_min,self.dac_max,self.frame_area,self.area_offset,self.device,self.baseband)
xep_operate.reset(self.device)
self.mc = ModuleConnector(self.device)
self.r=xep_operate.set_parameters(self.mc)
#存储数据
fI=np.linspace(0,self.fps-self.fps/self.buffer_size,self.buffer_size)
start_freq,mid_freq,end_freq = 0.1,0.8,2 #体征信号频率范围为0.1Hz-2Hz
start_point,mid_point,end_point = int(start_freq*self.buffer_size/self.fps),int(mid_freq*self.buffer_size/self.fps),int(end_freq*self.buffer_size/self.fps)
print (start_point,end_point)
myBuffer = my_xep.data_cache(self.buffer_size)
vital_detection = my_xep.data_process(self.fps)
self.show_list = [0]*self.buffer_size #原始信号
self.resp_list = [0]*(self.buffer_size*2) #呼吸信号
self.heart_list = [0]*(self.buffer_size*2) #心跳信号
iter = 1
while self._running:
new_frame = abs(xep_operate.read_frame(self.r))
new_frame = list(new_frame)
myBuffer.add(new_frame)
if iter%50==0:
print (len(myBuffer.buffer))
if iter>=self.buffer_size:
freq_rf,freq_hf = vital_detection.freq_get(np.transpose(np.array(myBuffer.buffer)),fI,start_point,mid_point,end_point,self.buffer_size)
freq_rf_num = '%.2f' %(freq_rf*60)
freq_hf_num = '%.2f' %(freq_hf*60)
print ('Rf is :',freq_rf_num,freq_hf_num)
self.window.m_textCtrl2.SetValue(freq_rf_num)
self.window.m_textCtrl3.SetValue(freq_hf_num)
#动态导入接收的信号
if iter%self.buffer_size == 0:
r_signal,h_signal = vital_detection.signal_divide(self.show_list)
#r_signal = r_signal/max(abs(r_signal))
r_signal = np.array(self.show_list)-np.mean(self.show_list)
r_signal = r_signal/max(abs(r_signal))
h_signal = h_signal/max(abs(h_signal))
self.resp_list[self.buffer_size:]=r_signal
self.heart_list[self.buffer_size:]=h_signal
self.resp_list = self.resp_list[1:]+[0]
self.heart_list = self.heart_list[1:]+[0]
#动态显示呼吸信号
self.window.axes_score.set_xlim(0*self.fps,self.buffer_size/self.fps)
#self.window.axes_score.set_ylim(0,max(self.resp_list[0:self.buffer_size])*1.2)
self.window.l_user.set_data(np.arange(200)/self.fps,self.resp_list[0:self.buffer_size])
self.window.axes_score.draw_artist(self.window.l_user)
#动态显示心跳信息
self.window.axes_score_new.set_xlim(0*self.fps,self.buffer_size/self.fps)
self.window.r_user.set_data(np.arange(200)/self.fps,self.heart_list[0:self.buffer_size])
self.window.axes_score.draw_artist(self.window.r_user)
self.window.canvas.draw()
self.show_list = self.show_list[1:]+[new_frame[vital_detection.maxDoor]]
iter += 1
self.r.x4driver_set_fps(0)
def main():
parser = OptionParser()
parser.add_option(
"-d",
"--device",
dest="device_name",
help="Seral port name used by target XeThru sensor, i.e com8, /dev/ttyACM0",
metavar="FILE")
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)
x4m200 = configure_x4m200(
device_name, options.record, x4m200_par_settings)
else:
player = start_player(meta_filename=options.meta_filename)
mc = ModuleConnector(player, log_level=0)
x4m200 = mc.get_x4m200()
print_x4m200_messages(x4m200)
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 start_player(meta_filename, depth=-1):
print("start playback from: {}, depth: {}".format(meta_filename, depth))
# ! [Typical usage]
player = DataPlayer(meta_filename, depth)
dur = player.get_duration()
print("Duration(ms): {}".format(dur))
mc = ModuleConnector(player, log_level=0)
# Control output
player.set_filter(pymoduleconnector.AllDataTypes)
player.set_playback_rate(1.0)
player.set_loop_mode_enabled(True)
player.play()
print("Player start to palyback data. If print or plot function is configured, it should start to work!")
return player
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()
class StreamData:
sampling_frequency = 17 # frames per second
def __init__(self, usb_port):
'''
Parser for streaming data from Xethru X4M300 presence sensor from Novelda.
:param usb_port: String
'''
self.usb_port = usb_port
self.mc = ModuleConnector(usb_port)
self.x4m300 = self.mc.get_x4m300()
self.x4m300.set_sensor_mode(XTID_SM_STOP, 0)
self.x4m300.load_profile(XTS_ID_APP_PRESENCE_2)
self.x4m300.set_output_control(XTS_ID_PRESENCE_SINGLE, 1)
self.x4m300.set_output_control(XTS_ID_BASEBAND_IQ, 1)
self.x4m300.set_sensor_mode(XTID_SM_RUN, 0)
def __iter__(self):
while True:
yield self.read_sensor()
def read_sensor(self):
'''
Read data from sensor
:return:
'''
messege = self.x4m300.read_message_baseband_iq()
i_data = []
q_data = []
for data in messege.i_data:
i_data = np.append(i_data, data)
for data in messege.q_data:
q_data = np.append(q_data, data)
return (i_data, q_data)
def main():
parser = OptionParser()
parser.add_option(
"-d",
"--device",
dest="device_name",
help="Seral port name used by target XeThru sensor, i.e com8, /dev/ttyACM0",
metavar="FILE")
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
mc = ModuleConnector(device_name)
start_record(mc)
else:
start_player(meta_filename=options.meta_filename)
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 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
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 x4m300_presence_simpleoutput(device_name,
detection_zone=(0.5, 9),
sensitivity=5,
num_messages=0):
# User settings
detzone_start = detection_zone[0]
detzone_end = detection_zone[1]
presence_state_text = []
presence_state_text.append("No presence")
presence_state_text.append("Presence")
presence_state_text.append("Initializing")
mc = ModuleConnector(device_name, log_level=0)
x4m300 = mc.get_x4m300()
sleep(1) # Allow for MC to read waiting messages from module.
try:
x4m300.set_sensor_mode(XTID_SM_STOP,
0) # Make sure no profile is running.
print("Stopped already running profile.")
except RuntimeError:
# If not initialized, stop returns error. Still OK, just wanted to make sure the profile was not running.
pass
# Now flush old messages from module
print("Flushing any old data.")
while x4m300.peek_message_presence_single():
presence_single = x4m300.read_message_presence_single()
# Read module info
print("FirmwareID:", x4m300.get_system_info(XTID_SSIC_FIRMWAREID))
print("Version:", x4m300.get_system_info(XTID_SSIC_VERSION))
print("Build:", x4m300.get_system_info(XTID_SSIC_BUILD))
print("Serial number:", x4m300.get_system_info(XTID_SSIC_SERIALNUMBER))
print("Loading new profile.")
x4m300.load_profile(XTS_ID_APP_PRESENCE_2)
print("Selecting module output.")
x4m300.set_output_control(XTS_ID_PRESENCE_SINGLE, 1) # PresenceSingle
x4m300.set_output_control(XTS_ID_PRESENCE_MOVINGLIST,
0) # PresenceMovingList
print("Setting user settings: DetectionZone = " + str(detzone_start) +
" to " + str(detzone_end) + ", Sensitivity = " + str(sensitivity))
x4m300.set_detection_zone(detzone_start, detzone_end)
x4m300.set_sensitivity(sensitivity)
print("Start profile execution.")
x4m300.set_sensor_mode(XTID_SM_RUN, 0) # Make sure no profile is running.
print("Waiting for data...")
n = 0
while num_messages == 0 or n < num_messages:
time.sleep(0.1)
while x4m300.peek_message_presence_single():
presence_single = x4m300.read_message_presence_single()
print("Presence ->" + " FrameCounter: " +
str(presence_single.frame_counter) + ", State: " +
presence_state_text[presence_single.presence_state] +
", Distance: " + str(round(presence_single.distance, 2)) +
", SignalQuality: " + str(presence_single.signal_quality))
n += 1
x4m300.set_sensor_mode(XTID_SM_STOP, 0)
def reset(device_name):
mc = ModuleConnector(device_name)
xep = mc.get_xep()
xep.module_reset()
mc.close()
time.sleep(1)
def x4m300_presence_simpleoutput(device_name, detection_zone=(0.5,9), sensitivity=5):
# User settings
detzone_start = detection_zone[0]
detzone_end = detection_zone[1]
#Reset module
reset(device_name)
mc = ModuleConnector(device_name, log_level=0)
x4m300 = mc.get_x4m300()
try:
x4m300.set_sensor_mode(13, 0) # Make sure no profile is running.
print("Stopped already running profile.")
except RuntimeError:
# If not initialized, stop returns error. Still OK, just wanted to make sure the profile was not running.
pass
# Read module info
print("FirmwareID: " + x4m300.get_system_info(2))
print("Version: " + x4m300.get_system_info(3))
print("Build: " + x4m300.get_system_info(4))
print("Serial number: " + x4m300.get_system_info(6))
print("Loading new profile.")
x4m300.load_profile(0x014d4ab8)
print("Selecting module output.")
x4m300.set_output_control(0x723bfa1f, 1) # PresenceMovingList
print("Setting user settings: DetectionZone = " + str(detzone_start) + " to " + str(detzone_end) + ", Sensitivity = " + str(sensitivity))
x4m300.set_detection_zone(detzone_start, detzone_end)
x4m300.set_sensitivity(sensitivity)
print("Start profile execution.")
x4m300.set_sensor_mode(1, 0) # Make sure no profile is running.
def clear_buffer():
"""Clears the frame buffer"""
while x4m300.peek_message_presence_movinglist():
x4m300.read_message_presence_movinglist()
def read_movlist_fast():
d = x4m300.read_message_presence_movinglist()
mfast = np.array(d.movement_fast_items)
mslow = np.array(d.movement_slow_items)
return mfast, mslow
def animate(i):
mfast, mslow = read_movlist_fast();
line1.set_ydata(mfast) # update the data
line2.set_ydata(mslow) # update the data
return line1, line2
d = x4m300.read_message_presence_movinglist()
State = d.presence_state
print("Initializing,this will take around 2mins")
while State == 2:
d = x4m300.read_message_presence_movinglist()
State = d.presence_state
print("Initializing Done!")
print("Start streaming movinglist...")
fig = plt.figure()
fig.suptitle("PresenceMovingList example")
ax1 = fig.add_subplot(2,1,1)
ax2 = fig.add_subplot(2,1,2)
ax2.set_xlabel('Distance')
ax1.set_ylabel('Fast Movement Metric')
ax2.set_ylabel('Slow Movement Metric')
mfast, mslow = read_movlist_fast()
#setting upperlimits for y-axsis
ax1.set_ylim(0,100)
ax2.set_ylim(0,100)
line1, = ax1.plot(mfast)
line2, = ax2.plot(mslow)
clear_buffer()
ani = FuncAnimation(fig, animate, interval=100)
plt.show()
# stop streaming
x4m300.set_sensor_mode(0x13, 0)
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)
def configure_x4m200(device_name,
record=False,
x4m200_settings=x4m200_par_settings):
mc = ModuleConnector(device_name)
x4m200 = mc.get_x4m200()
''' Following setting will enalbe debug info which contains MCU workload
mc = ModuleConnector(device_name, log_level=2)
x4m200 = mc.get_x4m200()
x4m200.set_debug_level(9)
mc.get_not_supported().set_parameter_file(
"profiling.par", "[Debug]\nprofileReportPeriod=10;\n")
'''
print('Clearing buffer')
while x4m200.peek_message_baseband_iq():
x4m200.read_message_baseband_iq()
while x4m200.peek_message_baseband_ap():
x4m200.read_message_baseband_ap()
while x4m200.peek_message_respiration_legacy():
x4m200.read_message_respiration_legacy()
while x4m200.peek_message_respiration_sleep():
x4m200.read_message_respiration_sleep()
while x4m200.peek_message_respiration_movinglist():
x4m200.read_message_respiration_movinglist()
while x4m200.peek_message_pulsedoppler_byte():
x4m200.read_message_pulsedoppler_byte()
while x4m200.peek_message_pulsedoppler_float():
x4m200.read_message_pulsedoppler_float()
while x4m200.peek_message_noisemap_byte():
x4m200.read_message_noisemap_byte()
while x4m200.peek_message_noisemap_float():
x4m200.read_message_noisemap_float()
print('Start recorder if recording is enabled')
if record:
start_recorder(mc)
print('Ensuring no Xethru profile running')
try:
x4m200.set_sensor_mode(XTID_SM_STOP, 0)
except RuntimeError:
print('Xethru module could not enter stop mode')
print('Loading new Xethru profile')
# x4m200.load_profile(XTS_ID_APP_RESPIRATION_2)# XTS_ID_APP_RESPIRATION_2 for adult and XTS_ID_APP_RESPIRATION_3 for baby
# XTS_ID_APP_RESPIRATION_2 for adult and XTS_ID_APP_RESPIRATION_3 for baby
x4m200.load_profile(XTS_ID_APP_RESPIRATION_2)
print('Set parameters')
for variable, value in x4m200_settings.items():
try:
if 'output_control' in variable:
variable = 'output_control'
setter_set = getattr(x4m200, 'set_' + variable)
except AttributeError as e:
print("X4M200 does not have a setter function for '%s'." %
variable)
raise e
if isinstance(value, tuple):
setter_set(*value)
else:
setter_set(value)
print("Setting %s to %s" % (variable, value))
print_sensor_settings(x4m200)
print('Set module to RUN mode')
try:
x4m200.set_sensor_mode(XTID_SM_RUN, 0) # RUN mode
except RuntimeError:
print('Xethru module cloud not enter run mode')
return x4m200
