def __init__(self):
super().__init__()
# Set up recorder class
self.rec = rcd.Recorder(device_name = 'Line (U24XL with SPDIF I/O)')
# Set up window parameter
Window.size = (500,500)
# Initialise root widget passing recorder class
self.rootwidget = RootWidget(rec = self.rec);
def main(argv=None):
logging.info("\n" * 3 + "="*100)
logging.info("starting recorder ")
if argv is None:
argv = sys.argv
helpText = '''
Please enter the following argumets
[1] name of the channel
[2] directory to store recordings
[3] time to record (optional) otherwise recording will continue till 0:00h the next day
like: "./runner.py Br_Klassik /User/Data"
'''
#too little arguments
if len(argv) < 3 or len(argv) > 4:
print(helpText)
sys.exit()
channel_name = argv[1]
directory = argv[2]
if len(argv) == 4:
time_to_record = 10 * int(argv[3]) #make minutes
else:
time_to_record = None
today = datetime.date.today()
# date = time.strftime('%Y-%m-%d', time.localtime())
start_time = time.strftime('%H-%M-%S', time.localtime())
db = Database.Database(directory)
db.init_RadioDB()
channel = db.find_channel_by_name(channel_name)
if channel is None:
print("There is no channel with that name")
sys.exit()
else:
try:
# start recording process
recorder = Recorder.Recorder(today, start_time, channel, directory, time_to_record)
recording = recorder.capture()
except RuntimeError as e:
exit("ERROR: {}".format(e.message))
# start audio processing and feature analysis
# digester = home + "/rrs/digesting_runner.py"
# Popen(["/usr/local/bin/python3", digester, directory, str(today), channel_name])
logging.info("Crawling process finished")
sys.exit(0)
def __init__(self):
self.exp_parameters = ExpParameters()
self.RESOURCES = sdl2.ext.Resources('.', 'resources')
self.display = Display.Display(self.RESOURCES, self.exp_parameters)
self.recorder = Recorder.Recorder(self.exp_parameters)
self.pID = 999
self.session = 99
self._setupSessions()
self._getPIDNSession()
def ivw_wakeup():
try:
msc_load_library = r'.\au\sdk\bin\msc_x64.dll'
app_id = '30cd05ef' # 填写自己的app_id
ivw_threshold = '0:1450'
jet_path = os.getcwd() + r'.\au\sdk\bin\msc\res\ivw\wakeupresource.jet'
work_dir = 'fo|' + jet_path
except Exception as e:
return e
# ret 成功码
MSP_SUCCESS = 0
dll = cdll.LoadLibrary(msc_load_library)
errorCode = c_int64()
sessionID = c_voidp()
# MSPLogin
Login_params = "appid={},engine_start=ivw".format(app_id)
Login_params = bytes(Login_params, encoding="utf8")
ret = dll.MSPLogin(None, None, Login_params)
if MSP_SUCCESS != ret:
logger.info("MSPLogin failed, error code is: %d", ret)
return
# QIVWSessionBegin
Begin_params = "sst=wakeup,ivw_threshold={},ivw_res_path={}".format(
ivw_threshold, work_dir)
Begin_params = bytes(Begin_params, encoding="utf8")
dll.QIVWSessionBegin.restype = c_char_p
sessionID = dll.QIVWSessionBegin(None, Begin_params, byref(errorCode))
if MSP_SUCCESS != errorCode.value:
logger.info("QIVWSessionBegin failed, error code is: {}".format(
errorCode.value))
return
# QIVWRegisterNotify
dll.QIVWRegisterNotify.argtypes = [c_char_p, c_voidp, c_voidp]
ret = dll.QIVWRegisterNotify(sessionID, pCallbackFunc, None)
if MSP_SUCCESS != ret:
logger.info("QIVWRegisterNotify failed, error code is: {}".format(ret))
return
# QIVWAudioWrite
recorder = Recorder.Recorder()
dll.QIVWAudioWrite.argtypes = [c_char_p, c_voidp, c_uint64, c_int64]
ret = MSP_SUCCESS
logger.info("* start recording")
while ret == MSP_SUCCESS:
audio_data = b''.join(recorder.get_record_audio())
audio_len = len(audio_data)
ret = dll.QIVWAudioWrite(sessionID, audio_data, audio_len, 2)
logger.info('QIVWAudioWrite ret =>{}', ret)
logger.info("* done recording")
recorder.__del__()
def __init__(self, loadfile=None):
self.rec = Recorder.Recorder()
self.keyboard = Keyboard()
self.done = 0
self.last_display = None
self.peak_meter = PeakMeter()
self.last_update = 0
if loadfile:
print 'Loading', loadfile
self.rec.load(loadfile)
def startRec(self):
""" Start recording """
rec = rc.Recorder(rate=22050, channels=1)
filePath = "rec"
with rec.open(filePath + ".wav", "wb") as recfile:
recfile.record(duration=5.0)
audioAnalyzer = aa.AudioAnalyzer()
if self._recognition:
voice = audioAnalyzer.checkAudio(filePath + ".wav")
bestUsers = audioAnalyzer.getBestUsers(voice)
print "Best users: {}".format(bestUsers)
print "_userId: " + self._userId
if self._userId in bestUsers:
msgBox = QtGui.QMessageBox()
msgBox.setText(
"Welcome {}! You have been authenticated.".format(
self._userId))
msgBox.setStandardButtons(QtGui.QMessageBox.Close)
msgBox.exec_()
else:
msgBox = QtGui.QMessageBox()
msgBox.setText("Two step authentication failed.")
msgBox.setStandardButtons(QtGui.QMessageBox.Close)
msgBox.exec_()
else:
print "Adding new user " + self._userId + " with file " + filePath
try:
success = audioAnalyzer.addUser(self._userId, filePath)
except IOError, e:
success = False
print "Error adding user: "******"rm -R " + filePath + "*") # remove all temp file
if success:
self.close()
return
msgBox = QtGui.QMessageBox()
msgBox.setText("Please speak more loudly.")
msgBox.setStandardButtons(QtGui.QMessageBox.Close)
msgBox.exec_()
def __record_video(self):
current_thread = threading.currentThread()
frames_per_second = \
RESOURCE_PROVIDER.get_string_table(RESOURCE_PROVIDER.CAMERA_FRAMERATE)
duration = RESOURCE_PROVIDER.get_string_table(RESOURCE_PROVIDER.CAMERA_DURATION)
while getattr(current_thread, 'is_running', True):
self.__record_video_enabled_lock.acquire()
condition = self.__record_video_enabled
self.__record_video_enabled_lock.release()
if bool(condition) is True:
file_name = self.__get_file_name()
self.__video_camera = Recorder.Recorder(\
file_name, False, str(duration), ["-fps", str(frames_per_second)])
self.__video_camera.start()
self.__thread_timer = time.time()
while self.__video_camera.isAlive():
if time.time() - self.__thread_timer > 300.0 / 1000.0:
if getattr(current_thread, 'is_running', False):
break
self.__thread_timer = time.time()
self.__video_camera.stop()
self.__video_camera.join()
print '[Video Manager] video_camera stopped '
while getattr(current_thread, 'is_running', True):
try:
self.__raw_files_queue.put(file_name, False)
except Queue.Full:
time.sleep(0.1)
continue
break
import numpy as np
import torch
import torch.nn as nn
import torchvision.transforms as transforms
# Other Library
from datetime import datetime
# Self-Defined Files
import Utils
import Config
import Recorder
# Models
import AlexNet, ResNet, LeNet5, MobileNet, NiNet
import SqueezeNet, myNet
# Recorder Instantiate
myRecorder = Recorder.Recorder()
torch.cuda.empty_cache()
# Fetch Models, Init & Copy
# model = ResNet.Fetch_ResNet('ResNet8v1')
# model = AlexNet.AlexNet()
# model = LeNet5.LeNet5()
# model = MobileNet.MobileNetv1()
# model = NiNet.NetworkInNetwork()
# model = SqueezeNet.Fetch_SqueezeNet('Bypass_Simple')
# model = SqueezeNet.SqueezeNet('Basic')
model = myNet.myNet(ResidualDepth = 2, DepthShrink = 0.5)
# print(model)
def writetofile(key):
keydata =str(key)
print(keydata)
if keydata=="Key.esc":
Listener.stop()
if Mode.ChooseMode(keydata):
return
elif Mode.getRecordMode(): #如果处于录音模式
if not Mode.getRecording():
Mode.setRecording(True)
a=recorder.Recorder(keydata)
Mode.setKeySet(keydata,a) #没有开始录音
a.start() #录音开始
elif Mode.getRecording() :
print("Recording mode On\nrecording stopped")
Mode.setRecording(False)
Mode.KeyToTrack[keydata].stop()
Mode.setPlayMode() #退出录音模式
elif Mode.getPlayMode(): #如果处于播放模式
if Mode.getLoopMode():
if keydata in Mode.KeyToTrack:
if Mode.KeyToTrack[keydata].getLooping():
Mode.KeyToTrack[keydata].stoploop()
else :
Mode.KeyToTrack[keydata].loop()
else:
return
else :
if keydata in Mode.KeyToTrack:
print(Mode.KeyToTrack[keydata].getLength())
Mode.KeyToTrack[keydata].play()
elif Mode.getSyncMode():
if Mode.ChoosingSyncMode:
Mode.ChosenTrackTime=Mode.KeyToTrack[keydata].getLength()
Mode.ChoosingSyncMode=False
print("Choose A Track To Record\n")
else:
if not Mode.getRecording():
Mode.setRecording(True)
a=recorder.Recorder(keydata)
Mode.setKeySet(keydata,a) #没有开始录音
a.startSync(Mode.ChosenTrackTime) #录音开始
print("Recording Start\n")
elif Mode.getRecording() :
print("recording stopped\n")
Mode.setRecording(False)
Mode.KeyToTrack[keydata].stop()
Mode.ChoosingSyncMode=True
Mode.setPlayMode() #退出录音模式
elif Mode.getFXMode():
if Mode.ChoosingFXMode:
Mode.ChosenFX=Mode.ChooseFX(keydata) #选择完效果
Mode.ChoosingFXMode=False #选择完效果
Mode.ChoosingTrackMode=True #选择完效果
print("Choose Your Tracks")
elif Mode.ChoosingTrackMode:
Mode.ChosenTrack.append(Mode.KeyToTrack[keydata])
if len(Mode.ChosenTrack)>=Mode.ChosenFX.getNumber():
Mode.ChoosingTrackMode=False
Mode.ChoosingKeyMode=True
print("Choose A Key For The New Track\n")
elif Mode.ChoosingKeyMode:
Mode.NewTrack=recorder.Recorder(keydata)
Mode.KeyToTrack[keydata]=Mode.NewTrack
Mode.giveFXtoTrack(Mode.ChosenTrack,Mode.NewTrack)
Mode.ChoosingKeyMode=False
Mode.ChoosingFXMode=True
Mode.ChosenTrack=[]
Mode.setPlayMode()
plot_frame2 = tk.Frame(root)
# plot_frame.pack_propagate(0)
plot_frame2.pack(fill='both', side='top', expand='True')
x_plot = Plot.Plot(plot_frame1, "both", "left", "True")
y_plot = Plot.Plot(plot_frame1, "both", "right", "True")
z_plot = Plot.Plot(plot_frame2, "both", "left", "True")
throttle_plot = Plot.Plot(plot_frame2, "both", "right", "True")
config = Config.Config("config.ini")
controller = Controller.Controller(root, "x", "bottom", "False", sender,
config)
plot_handler = PlotHandler.PlotHandler(x_plot, y_plot, z_plot,
throttle_plot)
recorder = Recorder.Recorder(args.recordpath)
def d(event):
plot_handler.redraw()
root.bind('<Configure>', d)
if args.mode == 0:
recorder.start_recording()
receiver = Receiver.Receiver(client_socket, plot_handler, recorder,
controller)
elif args.mode == 1:
receiver = Receiver.Receiver(client_socket, plot_handler, None,
controller)
recorder.playback_recording(receiver, args.recordpath)
else:
sendPCLock=sendPCLock)
exoClient.start()
# Initialize Recorder
name = input('Please input the name of this experiment:')
senName = 'Time,LHipPos,LKnePos,LAnkPos,SyncPin,RHipPos,RKnePos,RAnkPos,Test,Test'
conRecName = []
for val in valveCon.valveList:
conRecName.append(val.name)
pwmRecName = []
for pwmVal in valveCon.pwmValList:
pwmRecName.append(pwmVal.name)
recorder = Recorder.Recorder(name=name,
senRecQue=senRecQue,
senName=senName,
conRecQue=valveRecQue,
conRecName=conRecName,
syncTime=syncTimeQue,
pwmRecQue1=pwmRecQue1,
pwmRecQue2=pwmRecQue2,
pwmRecName=pwmRecName,
stateQue=stateQue)
def readCmd(cmdStr, cmdList):
startI = 0
endI = 0
while endI != len(cmdStr):
endI = cmdStr.find(',', startI)
if endI == -1:
endI = len(cmdStr)
cmdList.append(cmdStr[startI:endI])
startI = endI + 1
elif worldname == 'straight_6lane':
Track.append(seg.Segment('straight', (0, -75, pi / 2), 50))
Track.append(seg.Segment('straight', (0, -25, pi / 2), 50))
Track.append(seg.Segment('straight', (0, 25, pi / 2), 50))
Track.append(seg.Segment('straight', (0, 75, pi / 2), 50))
Track.append(seg.Segment('straight', (0, 125, pi / 2), 50))
Track.append(seg.Segment('straight', (0, 175, pi / 2), 50))
else:
print('no information about world:' + worldname + '! check out typo ')
trackinfo = Trackinfo.Trackinfo()
trackinfo.set_world(Track) # 생성한 segment list를 trackinfo에게 알려준다.
recorder = Recorder.Recorder(worldname, hz)
print 'data will be saved at ' + recorder.directory
print 'data file name : ' + recorder.filename
state = RUN
i = 0
while True:
if state == RUN:
trackinfo.current_segment = trackinfo.findSegment(
trackinfo.my_car.pose[0:2])
trackinfo.lane_number = trackinfo.findLane(
trackinfo.my_car.pose[0:2])
trackinfo.findSidelines(trackinfo.my_car.pose[0:2])
trackinfo.findDeviation(trackinfo.my_car.pose)
trackinfo.findHeading(trackinfo.my_car.pose)
import Control
import pyttsx3
import requests
import json
from tkinter import messagebox
# pip install jsonpath
# import jsonpath
def action():
data = entry1.get().strip()
control = Control.Order()
control.run(data)
rec = Recorder.Recorder()
def ok(event):
print('开始录音')
rec.start()
def no():
print('结束录音')
# 结束录音
rec.stop()
# 保存音频
file = rec.save('audio')
# 调用百度aip语音识别转义成文字
APP_ID = 'your APP_ID'
def run(self):
self.__is_running_lock.acquire()
self.__is_running = True
self.__is_running_lock.release()
self.__controller = Controller.Controller()
self.__recorder = Recorder.Recorder()
self.__communicator_server = CommunicatorServer.CommunicatorServer(self.get_ip_address())
self.__streamer_server = StreamerServer.StreamerServer(self.get_ip_address())
self.__data_provider_server = DataProviderServer.DataProviderServer(self.get_ip_address())
# control car motors thread
self.__controller_thread = \
threading.Thread(target=Controller.Controller.send_commands, \
args=(self.__controller, COMMANDS_QUEUE))
self.__controller_thread.setDaemon(True)
self.__controller_thread.start()
# get car data thread
self.__car_data_thread = \
threading.Thread(target=Controller.Controller.get_car_data, \
args=(self.__controller, CAR_DATA_QUEUE))
self.__car_data_thread.setDaemon(True)
self.__car_data_thread.start()
# video capture thread
self.__recorder_thread = \
threading.Thread(target=Recorder.Recorder.record, args=(self.__recorder, FRAME_QUEUE))
self.__recorder_thread.setDaemon(True)
self.__recorder_thread.start()
# streamer server thread
self.__streamer_thread = \
threading.Thread(target=self.__streamer_server.stream, \
args=(FRAME_QUEUE,))
self.__streamer_thread.setDaemon(True)
self.__streamer_thread.start()
# comunicator server thread
self.__communicator_thread = \
threading.Thread(target=self.__communicator_server.update_user_commands, \
args=(USER_COMMANDS_QUEUE,))
self.__communicator_thread.setDaemon(True)
self.__communicator_thread.start()
# data provider server thread
self.__data_provider_thread = \
threading.Thread(target=self.__data_provider_server.provide, \
args=(CAR_DATA_QUEUE,))
self.__data_provider_thread.setDaemon(True)
self.__data_provider_thread.start()
# user commands thread
self.__process_user_commands_thread = \
threading.Thread(target=self.__process_user_commands, \
args=(USER_COMMANDS_QUEUE, COMMANDS_QUEUE,))
self.__process_user_commands_thread.setDaemon(True)
self.__process_user_commands_thread.start()
print '[CarManager] Am startat tot'
while True:
self.__is_running_lock.acquire()
condition = self.__is_running
self.__is_running_lock.release()
if bool(condition) is False:
self.stop()
break
time.sleep(1)
# -*- coding: utf-8 -*-
from Recorder import *
from module309 import *
if __name__ == '__main__':
frame = 13 * [0]
s = createSignal(frame)
rec = Recorder(channels=2)
with rec.open('sine.wav', 'wb') as recfile:
recfile.record(duration=5.0)
playSignal(s)
def __init__(self, filename, options):
gr.top_block.__init__(self, "MULTIRX2")
config = configuration.Configuration(filename)
self.center_freq = config.center()
self.save_dir = config.save_dir()
print("Starting Multirx ...")
print("low=%d center=%d high=%d span=%d" %
(config.lower(), config.center(), config.upper(),
(config.upper() - config.lower())))
self.samp_rate = samp_rate = 1E6
dev_args = "numchan=" + str(1) + " rtl=" + config.serial()
print("Device Args: %s" % dev_args)
self.osmosdr_source = osmosdr.source(args=dev_args)
self.osmosdr_source.set_sample_rate(samp_rate)
self.osmosdr_source.set_center_freq(self.center_freq, 0)
self.osmosdr_source.set_freq_corr(config.freq_corr(), 0)
self.osmosdr_source.set_dc_offset_mode(0, 0)
self.osmosdr_source.set_iq_balance_mode(0, 0)
if config.gain() == 0:
self.osmosdr_source.set_gain_mode(True, 0)
else:
self.osmosdr_source.set_gain_mode(False, 0)
self.osmosdr_source.set_gain(config.gain(), 0)
self.osmosdr_source.set_if_gain(20, 0)
self.osmosdr_source.set_bb_gain(20, 0)
self.osmosdr_source.set_antenna("", 0)
self.osmosdr_source.set_bandwidth(0, 0)
self.blocks_adder = blocks.add_vss(1)
for self.i, self.entry in enumerate(config.channel):
self.demod_bb_freq = self.entry[1] - self.center_freq
self.ctcss_freq = self.entry[3]
self.postscript = self.entry[4]
self.squelch = self.entry[5]
self.demod = Demodulator.Demodulator(self.samp_rate, \
self.demod_bb_freq, self.squelch, self.ctcss_freq)
self.fname = self.setup_upstream_pipe(self.entry[0], self.entry[2],
config)
self.file_sink = blocks.file_sink(gr.sizeof_short * 1, self.fname,
True)
self.connect((self.osmosdr_source, 0), (self.demod, 0),
(self.file_sink, 0))
self.connect((self.demod, 0), (self.blocks_adder, self.i))
self.rec = Recorder.Recorder(16000, self.entry[0], self.save_dir,
self.postscript)
self.connect((self.demod, 0), (blocks.short_to_float(1, 32768), 0),
(self.rec, 0))
time.sleep(1) #space things out a bit
if options.multiplex:
self.fname = self.setup_upstream_pipe("multiplex",
"Multiplex Channel")
self.file_sink = blocks.file_sink(gr.sizeof_short * 1, self.fname,
True)
self.connect((self.blocks_adder, 0), (self.file_sink, 0))
if options.local:
self.audio_sink = audio.sink(16000, "", True)
self.blocks_short_to_float = blocks.short_to_float(1, 32768)
self.connect((self.blocks_adder, 0),
(self.blocks_short_to_float, 0), (self.audio_sink, 0))
if not options.multiplex and not options.local:
self.connect((self.blocks_adder, 0),
(blocks.null_sink(gr.sizeof_short * 1), 0))
def __init__(self):
self.rec = Recorder.Recorder() # with default params
self.make_gui()
every(self.tk, 100, self.update_display)
