def __init__(self, port, baund=9600): self.sendbuf = Zkzt2_ST(code, addr) #定义发送结构体 self.recvbuf = Zkzt2_ST() #定义接收结构体 self.ser = SerialPort(port, baund) #初始化串口 self.ser.open() #打开串口
def __init__(self, port, baund=9600): self.rcflg = 0 #接收成功标识 self.rcbuf = PcComInfo(0, 0, 0) #接收数据 self.ser = SerialPort(port, baund) #初始化串口 self.ser.open() #打开串口 pcThread = threading.Thread(target=self.ser.recv) #创建多线程,启动接收任务 pcThread.start()
def __init__(self): self.login = MainApp() self.cpuThread = QThread() self.scannerThread = QThread() self.open_admin = False self.open_user = False self.open_stats = False self.cpu = SerialPort('CPU') self.scanner = SerialPort('Scanner') self.cpu.moveToThread(self.cpuThread) self.scanner.moveToThread(self.scannerThread)
def checkMode(self): inputTxt = [] inputTxt.append('MD') serialportObj = SerialPort.SerialConnection() ser = serialportObj.open_connection() outTxt = serialportObj.serialIO(inputTxt, ser) return (outTxt)
def __init__(self, sync_event, spike_listener, position_estimator, place_field_handler): """TODO: to be defined1. """ ThreadExtension.StoppableProcess.__init__(self) self._sync_event = sync_event self._spike_buffer = collections.deque(maxlen=self._SPIKE_BUFFER_SIZE) self._spike_histogram = collections.Counter() self._spike_buffer_connection = spike_listener.get_spike_buffer_connection( ) self._position_buffer_connection = position_estimator.get_position_buffer_connection( ) self._place_field_handler = place_field_handler self._position_access = Lock() self._spike_access = Lock() # TODO: This functionality should be moved to the parent class self._enable_synchrnoizer = Lock() self._is_disabled = Value("b", True) # Position data at the time ripple is triggered self._pos_x = -1 self._pos_y = -1 self._most_recent_speed = 0 self._most_recent_pos_timestamp = 0 self._serial_port = None try: self._serial_port = SerialPort.BiphasicPort() except Exception as err: logging.warning("Unable to open Serial port.") print(err) logging.info(self.CLASS_IDENTIFIER + "Started Ripple Synchronization thread.")
def scanMode(self): inputTxt = [] inputTxt.append('KEY00') serialportObj = SerialPort.SerialConnection() ser = serialportObj.open_connection() serialportObj.serialIO(inputTxt, ser) return None
def main(): global task_end_flag, task, DEBUG, task_running detector = Detector() with SerialPort('/dev/serial0', 9600, None) as sp: while True: if sp.receiveData(): # 复位检测器 detector.reset() try: detect_type = sp.getReceive()['byte'][0] if DEBUG: print(detect_type) # 等待 if detect_type == 0: if task is not None and task_running: task_end_flag = True task.join() task_end_flag = False task = Thread(target=waiting) task.start() # 3数字二维码 if detect_type == 1: if task is not None and task_running: task_end_flag = True task.join() task_end_flag = False task = Thread(target=detect_qrcode, args=[detector, sp,]) task.start() # 3色块 elif detect_type == 2: if task is not None and task_running: task_end_flag = True task.join() task_end_flag = False task = Thread(target=detect_color, args=[detector, sp,]) task.start() # 3+3数字二维码 elif detect_type == 3: if task is not None and task_running: task_end_flag = True task.join() task_end_flag = False task = Thread(target=detect_qrcode, args=[detector, sp, 1]) task.start() # 3颜色条形码 elif detect_type == 4: if task is not None and task_running: task_end_flag = True task.join() task_end_flag = False task = Thread(target=detect_qrcode, args=[detector, sp, 2]) task.start() except: pass else: if not task_running and DISPLAY: task = Thread(target=display) task.start()
def viewScannerChannel(self, channelNum): self.__channelNum = channelNum channelNumPadded = str("{0:0>3}".format(channelNum)) #print(channelNumPadded) inputTxt = [] #inputTxt.append('MA' + channelNumPadded) inputTxt.append('PM' + channelNumPadded) # Print Memory Data #ser=sc.serObj(sc) serialportObj = SerialPort.SerialConnection() ser = serialportObj.open_connection() outTxt = serialportObj.serialIO(inputTxt, ser) #channelTxt = '' #channelTxt = 'Freq: ' + outTxt[6:10] + '.' + outTxt[10:14] + 'MHz' #channelTxt = '' #outTxtFreq = outTxt[6:14] #return(channelTxt.join(outTxtFreq)) #return(outTxt, channelTxt) outTxtFreq = outTxt #outTxtFreq = outTxt[1:33] #outTxtFreq = outTxt[6:14] # Just grab frequency # list comprehension. Turns list to string. # Works for list with mixed element types (if applicable) channelTxt = ''.join([str(element) for element in outTxtFreq]) #print(channelTxt) return channelTxt
def manualMode(self): inputTxt = [] inputTxt.append('KEY01') serialportObj = SerialPort.SerialConnection() ser = serialportObj.open_connection() serialportObj.serialIO(inputTxt, ser) scanner.freq_display() return None
class Zkzt2Data: def __init__(self, port, baund=9600): self.sendbuf = Zkzt2_ST(code, addr) #定义发送结构体 self.recvbuf = Zkzt2_ST() #定义接收结构体 self.ser = SerialPort(port, baund) #初始化串口 self.ser.open() #打开串口 #pcThread = threading.Thread(target = self.ser.recv) #创建多线程,启动接收任务 #pcThread.start() def stop(self): self.sendbuf.status = STA_STOP self.sendbuf.bcc = Checker.GetBccCheck(ctypes.byref(self.sendbuf), ctypes.sizeof(Zkzt2_ST) - 1) print(self.sendbuf.status, self.sendbuf.bcc) self.ser.send(self.sendbuf) def setSpeed(self, speed, frq=1000, direction=STA_CW): self.sendbuf.status = direction #设置状态,默认正转 self.sendbuf.speedH = 0x00 self.sendbuf.speedL = speed print(frq, frq >> 8, frq) self.sendbuf.frqH = frq >> 8 self.sendbuf.frqL = frq self.sendbuf.bcc = Checker.GetBccCheck(ctypes.byref(self.sendbuf), ctypes.sizeof(Zkzt2_ST) - 1) print(self.sendbuf.status, self.sendbuf.bcc) self.ser.send(self.sendbuf)
class PcComm: def __init__(self, port, baund=9600): self.rcflg = 0 #接收成功标识 self.rcbuf = PcComInfo(0, 0, 0) #接收数据 self.ser = SerialPort(port, baund) #初始化串口 self.ser.open() #打开串口 pcThread = threading.Thread(target=self.ser.recv) #创建多线程,启动接收任务 pcThread.start() def recvThread(self): while True: time.sleep(0.2) #循环周期 if (self.ser.recv_len): #数据接收成功 Crc.GetCheckSum.restype = c_uint8 #GetCheckSum 返回值类型 crc = Crc.GetCheckSum(self.ser.recv_buf, self.ser.recv_len - 1) #计算校验和 #print(self.ser.recv_buf) #print(crc,self.ser.recv_buf[self.ser.recv_len-1]) if (crc == self.ser.recv_buf[self.ser.recv_len - 1]): #校验正确 self.ser.send(send_buf) #发送应答,标识接收正常 #self.rcbuf = self.ser.recv_buf[2:self.ser.recv_len-1] self.rcbuf.motor = self.ser.recv_buf[2] self.rcbuf.sensor = self.ser.recv_buf[3] #print(self.ser.recv_buf[4],self.ser.recv_buf[4]<<8,self.ser.recv_buf[5]) self.rcbuf.rotate = (int(self.ser.recv_buf[4]) + int(self.ser.recv_buf[5] << 8)) #print("struct:",self.rcbuf.motor,self.rcbuf.sensor,self.rcbuf.rotate) #print(self.rcbuf) self.rcflg = 1 #置接收成功标识 self.ser.recv_len = 0 #清除进入循环条件
def programScannerChannel(self, channelNum, channel): # list version self.__channelNum = channelNum self._channel = channel channelNumPadded = str("{0:0>3}".format(channelNum)) inputTxt = [] freqStr = str("{0:0>8}".format(round(channel.viewFreq()))) #print(freqStr) inputTxt.append('PM' + str(channelNumPadded) + ' ' + freqStr) modeStr = channel.viewMode() inputTxt.append('RM' + ' ' + modeStr) serialportObj = SerialPort.SerialConnection() ser = serialportObj.open_connection() outTxt = serialportObj.serialIO(inputTxt, ser) #outTxt = connection.serialIO(inputTxt) return (outTxt)
def main(): # todo : 기본설정파일 로딩 (JSON 텍스트 파일 형식) makeJsonInit() # 설정 파일을 새로 만들 때 만 호출한다. dict_setting = json_loading("setting.json") print(dict_setting) # todo : 시리얼 통신 스레드를 연다. c_serial_port = SerialPort.SerialPort(dict_setting["SERIAL"]["PORT"], dict_setting["SERIAL"]["BAUD"], rcv_callback, send_thread) c_serial_port.threading() while (True): print("main sleep") time.sleep(1)
def __init__(self, serial_port_id, physical_device_id): """ serial_port_id -> Give the serial port id as a variable name (i.e serial_port_2) Object can be addressed but serves as glue between SerialPort and Pin :param serial_port_id: :return: """ super(Arduino, self).__init__(serial_port_id.serial_port, serial_port_id.baud_rate, serial_port_id.time_out, serial_port_id.serial_port_id) self.arduino_attr = SerialPort(self.serial_port, self.baud_rate, self.time_out, self.serial_port_id) self.physical_device_id = physical_device_id
def freq_display(): inputTxt = [] inputTxt.append('MA') # get frequency serialportObj = SerialPort.SerialConnection() ser = serialportObj.open_connection() outTxt = serialportObj.serialIO(inputTxt, ser) #channelTxt = 'Freq: ' + outTxt[6:10] + '.' + outTxt[10:14] + 'MHz' outTxtFreq = outTxt[6:13] channelTxt = ''.join([str(element) for element in outTxtFreq]) outFreq = float(channelTxt) / 1000 outFreq4dp = "{:.4f}".format(outFreq) display_message = 'Freq: ' + outFreq4dp + 'MHz' window = Tk() window.title("Frequency") window.geometry('350x200') txt = scrolledtext.ScrolledText(window, font='Verdana 11', width=40, height=10) txt.grid(column=0, row=0) txt.insert(INSERT, display_message) window.mainloop()
def __init__(self): self.serialPort = SerialPort()
print '[LOG] current frequency:', freq, 'Hz' sp.blinkSSVEP([freq, 0], 1, 1) time.sleep(time_length) sp.blinkSSVEP([0, 0], 1, 1) if freqs[freq] >= number_iterations: del freqs[freq] print '[LOG] removing frequency:', freq, 'Hz' print '' sp = Sp.SerialPort('/dev/ttyUSB0') sp.open() sp.blinkSSVEP([0, 0], 1, 1) print('Starting Task 1') raw_input('Are you ready? ...') task_1(sp) raw_input('Are you ready? ...') task_1(sp) sp.close()
class CromeQD2: def calcTempInCelsius(self,raw): raw = raw / 51. raw = (0.1423*pow(raw,6)) - (2.4938*pow(raw,5)) + (17.837*pow(raw,4)) - (68.698*pow(raw,3)) + (154.69*pow(raw,2)) - (232.75*raw) + 284.24 return ((raw - 32.)*5.)/9. def __init__(self): self.serialPort = SerialPort() def getGear(self): gearRaw = self.serialPort.getByteFromThree(GEAR_B1_CROME14,GEAR_B2_CROME14,GEAR_B3_CROME14) return gearRaw def getRpm(self): try: rpmLowRaw=self.serialPort.getByte(RPMLOW_CROME14) rpmHighRaw=self.serialPort.getByte(RPMHIGH_CROME14) return 1851562/((rpmHighRaw * 256) + rpmLowRaw) except: return 0 def getBattery(self): batteryRaw = self.serialPort.getByte(BATT_CROME14) return (26.0 * batteryRaw) / 270.0 def getIat(self): iatRaw = self.serialPort.getByte(IAT_CROME14) return self.calcTempInCelsius(iatRaw) def getEct(self): ectRaw = self.serialPort.getByte(ECT_CROME14) return self.calcTempInCelsius(ectRaw) def getTps(self): tpsRaw = self.serialPort.getByte(TPS_CROME14) tpsRaw = (0.4716 * tpsRaw) - 11.3184 return tpsRaw def getO2(self): o2Raw = self.serialPort.getByte(O2_CROME14) return (2*o2Raw) + 10 def getVss(self): vssRaw = self.serialPort.getByte(VSS_CROME14) return vssRaw def getMap(self): mapRaw = self.serialPort.getByte(MAP_CROME14) return (1764/255)*mapRaw def getInj(self): injLowRaw = self.serialPort.getByte(INJLOW_CROME14) injHighRaw = self.serialPort.getByte(INJHIGH_CROME14) injRaw = (injHighRaw * 256) + injLowRaw; return injRaw / 352 def getIgn(self): ignRaw = self.serialPort.getByte(IGN_CROME14) return (0.25 * ignRaw) - 6 def getDutyCycle(self): rpm = self.getRpm() inj = self.getInj() return (rpm * inj) / 1200 def getVtec(self): vtec = self.serialPort.getByte(VTEC_CROME14) if (vtec == 67): return True else: return False
############################################################################## ''' IMPORT ''' ############################################################################## import config import SerialPort import WhatsappFuncs ############################################################################## ''' INISIASI ''' ############################################################################## ############################################################################## ''' MAIN LOOP ''' ############################################################################## if __name__ == '__main__': config.init_config() SerialPort.init_serial() WhatsappFuncs.whatsapp_login() SerialPort.start_SMS_reader()
def getRippleStatistics(tetrodes, analysis_time=4, show_ripples=False, \ ripple_statistics=None, interrupt_ripples=False): """ Get ripple data statistics for a particular tetrode and a user defined time period. Added: 2019/02/19 Archit Gupta :tetrodes: Indices of tetrodes that should be used for collecting the statistics. :analysis_time: Amount of time (specified in seconds) for which the data should be analyzed to get ripple statistics. :show_ripple: Show ripple as they happen in real time. :ripple_statistics: Mean and STD for declaring something a sharp-wave ripple. :returns: Distribution of ripple power, ripple amplitude and frequency """ if show_ripples: plt.ion() if interrupt_ripples: ser = SerialPort.BiphasicPort() n_tetrodes = len(tetrodes) report_ripples = (ripple_statistics is not None) # Create a ripple filter (discrete butterworth filter with cutoff # frequencies set at Ripple LO and HI cutoffs.) ripple_filter = signal.butter(RiD.LFP_FILTER_ORDER, \ (RiD.RIPPLE_LO_FREQ, RiD.RIPPLE_HI_FREQ), \ btype='bandpass', analog=False, output='sos', \ fs=RiD.LFP_FREQUENCY) # Filter the contents of the signal frame by frame ripple_frame_filter = signal.sosfilt_zi(ripple_filter) # Tile it to take in all the tetrodes at once ripple_frame_filter = np.tile(np.reshape(ripple_frame_filter, \ (RiD.LFP_FILTER_ORDER, 1, 2)), (1, n_tetrodes, 1)) # Initialize a new client client = TrodesInterface.SGClient("RippleAnalyst") if (client.initialize() != 0): del client raise Exception("Could not initialize connection! Aborting.") # Access the LFP stream and create a buffer for trodes to fill LFP data into lfp_stream = client.subscribeLFPData( TrodesInterface.LFP_SUBSCRIPTION_ATTRIBUTE, tetrodes) lfp_stream.initialize() # LFP Sampling frequency TIMES desired analysis time period N_DATA_SAMPLES = int(analysis_time * RiD.LFP_FREQUENCY) # Each LFP frame (I think it is just a single time point) is returned in # lfp_frame_buffer. The entire timeseries is stored in raw_lfp_buffer. lfp_frame_buffer = lfp_stream.create_numpy_array() ripple_filtered_lfp = np.zeros((n_tetrodes, N_DATA_SAMPLES), dtype='float') raw_lfp_buffer = np.zeros((n_tetrodes, N_DATA_SAMPLES), dtype='float') ripple_power = np.zeros((n_tetrodes, N_DATA_SAMPLES), dtype='float') # Create a plot to look at the raw lfp data timestamps = np.linspace(0, analysis_time, N_DATA_SAMPLES) iter_idx = 0 prev_ripple = -1.0 prev_interrupt = -1.0 # Data to be logged for later use ripple_events = [] trodes_timestamps = [] wall_ripple_times = [] interrupt_events = [] if report_ripples: print('Using pre-recorded ripple statistics') print('Mean: %.2f' % ripple_statistics[0]) print('Std: %.2f' % ripple_statistics[1]) if show_ripples: interruption_fig = plt.figure() interruption_axes = plt.axes() plt.plot([], []) plt.grid(True) plt.ion() plt.show() wait_for_user_input = input("Press Enter to start!") start_time = 0.0 start_wall_time = time.perf_counter() interruption_iter = -1 is_first_ripple = True while (iter_idx < N_DATA_SAMPLES): n_lfp_frames = lfp_stream.available(0) for frame_idx in range(n_lfp_frames): # print("t__%.2f"%(float(iter_idx)/float(RiD.LFP_FREQUENCY))) t_stamp = lfp_stream.getData() trodes_time_stamp = client.latestTrodesTimestamp() raw_lfp_buffer[:, iter_idx] = lfp_frame_buffer[:] # If we have enough data to fill in a new filter buffer, filter the # new data if (iter_idx > RiD.RIPPLE_SMOOTHING_WINDOW) and ( iter_idx % RiD.LFP_FILTER_ORDER == 0): lfp_frame = raw_lfp_buffer[:, iter_idx - RiD.LFP_FILTER_ORDER:iter_idx] # print(lfp_frame) filtered_frame, ripple_frame_filter = signal.sosfilt(ripple_filter, \ lfp_frame, axis=1, zi=ripple_frame_filter) # print(filtered_frame) ripple_filtered_lfp[:, iter_idx - RiD. LFP_FILTER_ORDER:iter_idx] = filtered_frame # Averaging over a longer window to be able to pick out ripples effectively. # TODO: Ripple power is only being reported for each frame # right now: Filling out the same value for the entire frame. frame_ripple_power = np.sqrt(np.mean(np.power( \ ripple_filtered_lfp[:,iter_idx-RiD.RIPPLE_SMOOTHING_WINDOW:iter_idx], 2), axis=1)) ripple_power[:,iter_idx-RiD.LFP_FILTER_ORDER:iter_idx] = \ np.tile(np.reshape(frame_ripple_power, (n_tetrodes, 1)), (1, RiD.LFP_FILTER_ORDER)) if report_ripples: if is_first_ripple: is_first_ripple = False else: # Show the previous interruption after a sufficient time has elapsed if show_ripples: if (iter_idx == int( (prev_ripple + RiD.INTERRUPTION_WINDOW) * RiD.LFP_FREQUENCY)): data_begin_idx = int( max(0, iter_idx - 2 * RiD.INTERRUPTION_TPTS)) interruption_axes.clear() interruption_axes.plot(timestamps[data_begin_idx:iter_idx], raw_lfp_buffer[0, \ data_begin_idx:iter_idx]) interruption_axes.scatter(prev_ripple, 0, c="r") interruption_axes.set_ylim(-3000, 3000) plt.grid(True) plt.draw() plt.pause(0.001) # print(raw_lfp_buffer[0, data_begin_idx:iter_idx]) # If any of the tetrodes has a ripple, let's call it a ripple for now ripple_to_baseline_ratio = (frame_ripple_power[0] - ripple_statistics[0])/ \ ripple_statistics[1] if (ripple_to_baseline_ratio > RiD.RIPPLE_POWER_THRESHOLD): current_time = float(iter_idx) / float( RiD.LFP_FREQUENCY) if ((current_time - prev_ripple) > RiD.RIPPLE_REFRACTORY_PERIOD): prev_ripple = current_time current_wall_time = time.perf_counter( ) - start_wall_time time_lag = (current_wall_time - current_time) if interrupt_ripples: ser.sendBiphasicPulse() print( "Ripple @ %.2f, Real Time %.2f [Lag: %.2f], strength: %.1f" % (current_time, current_wall_time, time_lag, ripple_to_baseline_ratio)) trodes_timestamps.append(trodes_time_stamp) ripple_events.append(current_time) wall_ripple_times.append(current_wall_time) iter_idx += 1 if (iter_idx >= N_DATA_SAMPLES): break if client is not None: client.closeConnections() print("Collected raw LFP Data. Visualizing.") power_mean, power_std = Visualization.visualizeLFP(timestamps, raw_lfp_buffer, ripple_power, \ ripple_filtered_lfp, ripple_events, do_animation=False) if report_ripples: writeLogFile(trodes_timestamps, ripple_events, wall_ripple_times, interrupt_events) # Program exits with a segmentation fault! Can't help this. wait_for_user_input = input('Press ENTER to quit') return (power_mean, power_std)
def initServer(self): self.UART = SerialPort(PORT, BAUDRATE) if self.UART.SUCCESS_OPEN: self.__serverSuccessFlag = True else: self.__serverSuccessFlag = False
class CromeQD2: def calcTempInCelsius(self, raw): raw = raw / 51.0 raw = ( (0.1423 * pow(raw, 6)) - (2.4938 * pow(raw, 5)) + (17.837 * pow(raw, 4)) - (68.698 * pow(raw, 3)) + (154.69 * pow(raw, 2)) - (232.75 * raw) + 284.24 ) return ((raw - 32.0) * 5.0) / 9.0 def __init__(self): self.serialPort = SerialPort() def getGear(self): gearRaw = self.serialPort.getByteFromThree(GEAR_B1_CROME14, GEAR_B2_CROME14, GEAR_B3_CROME14) return gearRaw def getRpm(self): try: rpmLowRaw = self.serialPort.getByte(RPMLOW_CROME14) rpmHighRaw = self.serialPort.getByte(RPMHIGH_CROME14) return 1851562 / ((rpmHighRaw * 256) + rpmLowRaw) except: return 0 def getBattery(self): batteryRaw = self.serialPort.getByte(BATT_CROME14) return (26.0 * batteryRaw) / 270.0 def getIat(self): iatRaw = self.serialPort.getByte(IAT_CROME14) return self.calcTempInCelsius(iatRaw) def getEct(self): ectRaw = self.serialPort.getByte(ECT_CROME14) return self.calcTempInCelsius(ectRaw) def getTps(self): tpsRaw = self.serialPort.getByte(TPS_CROME14) tpsRaw = (0.4716 * tpsRaw) - 11.3184 return tpsRaw def getO2(self): o2Raw = self.serialPort.getByte(O2_CROME14) return (2 * o2Raw) + 10 def getVss(self): vssRaw = self.serialPort.getByte(VSS_CROME14) return vssRaw def getMap(self): mapRaw = self.serialPort.getByte(MAP_CROME14) return (1764 / 255) * mapRaw def getInj(self): injLowRaw = self.serialPort.getByte(INJLOW_CROME14) injHighRaw = self.serialPort.getByte(INJHIGH_CROME14) injRaw = (injHighRaw * 256) + injLowRaw return injRaw / 352 def getIgn(self): ignRaw = self.serialPort.getByte(IGN_CROME14) return (0.25 * ignRaw) - 6 def getDutyCycle(self): rpm = self.getRpm() inj = self.getInj() return (rpm * inj) / 1200 def getVtec(self): vtec = self.serialPort.getByte(VTEC_CROME14) if vtec == 67: return True else: return False
class Controller: def __init__(self): self.login = MainApp() self.cpuThread = QThread() self.scannerThread = QThread() self.open_admin = False self.open_user = False self.open_stats = False self.cpu = SerialPort('CPU') self.scanner = SerialPort('Scanner') self.cpu.moveToThread(self.cpuThread) self.scanner.moveToThread(self.scannerThread) def showLogin(self): if self.cpu.ComPort is None: self.cpu.portConnect() try: self.cpu.close() except Exception as e: print("Error Port :", e) if self.scanner.ComPort is None: self.scanner.portConnect() try: self.scanner.close() except Exception as e: print("Error Port:", e) self.login.QTxtLogin.setText('') self.login.QTxtPass.setText('') if not self.login.loaded: self.login.switchWindow.connect(self.showUser) self.login.loaded = True if self.open_admin: self.admin.close() if self.open_user: self.user.close() self.login.show() def showUser(self, text): try: self.cpuThread.started.disconnect() self.cpuThread.terminate() self.scannerThread.started.disconnect() self.scannerThread.terminate() except Exception as e: print(e) users = pd.read_csv(home_path[:-4] + '/files/users.csv') res = users[(users['username'] == text)] if res['username'].item() == "admin": if not self.open_admin: self.admin = Admin('') self.open_admin = True self.admin.login = text self.admin.handleHeaders() if not self.admin.loaded: self.admin.switchWindow.connect(self.showLogin) self.admin.switchWindow2.connect(self.showStats) self.admin.loaded = True if self.open_stats: self.stats.close() self.login.close() self.admin.show() else: if not self.open_user: self.user = User('') self.open_user = True self.user.QTxtRef.setText('') self.user.login = text self.user.handleHeaders() self.user.handleUI() if not self.user.loaded: self.user.switchWindow.connect(self.showLogin) self.user.switchWindow2.connect(self.showStats) self.user.sendsignal.connect(self.sendToOutput) self.user.loaded = True self.cpu.open() self.scanner.open() if not self.cpu.is_connected: self.cpu.signal.connect(self.user.recieveData) self.cpu.is_connected = True if not self.scanner.is_connected: self.scanner.signal.connect(self.user.recieveData) self.scanner.is_connected = True self.cpuThread.started.connect(self.cpu.readSerialPort) self.scannerThread.started.connect(self.scanner.readSerialPort) self.cpuThread.setTerminationEnabled(True) self.cpuThread.start() self.scannerThread.setTerminationEnabled(True) self.scannerThread.start() self.login.close() if self.open_stats: self.stats.close() self.user.show() def sendToOutput(self, data): print('[+]Sending', data, 'to serial port') self.cpu.writeSerialPort(data) def showScan(self, text): if not self.open_scan: self.scan = Scan('') self.open_scan = True self.scan.login = text.split(';')[0] self.scan.reference = text.split(';')[1] self.scan.quantity = int(text.split(';')[2]) self.scan.processed = 0 self.scan.handleHeaders() self.scan.handel_progressBar() if not self.scan.loaded: self.scan.switchWindow.connect(self.showUser) self.scan.loaded = True self.cpu.moveToThread(self.cpuThread) self.cpu.signal.connect(self.scan.recieveData) self.cpuThread.started.connect(self.cpu.readSerialPort) self.cpuThread.setTerminationEnabled(True) self.cpuThread.start() self.scanner.moveToThread(self.scannerThread) self.scanner.signal.connect(self.scan.recieveData) self.scannerThread.started.connect(self.scanner.readSerialPort) self.scannerThread.setTerminationEnabled(True) self.scannerThread.start() self.user.close() time.sleep(0.5) self.scan.show() def showStats(self, text): try: self.serialPort.close() except Exception as e: print("error PORT :", e) if not self.open_stats: self.stats = Statistics('') self.open_stats = True self.stats.login = text self.stats.handleHeaders() if not self.stats.loaded: self.stats.switchWindow.connect(self.showUser) self.stats.loaded = True self.stats.show() if self.open_admin: self.admin.close() if self.open_user: self.user.close()
def scanner(): global ChannelList global minChannel global maxChannel global inputValidation global connection inputValidation = { 'channelRange': [minChannel, maxChannel], 'freqRange': [[25, 512], [806, 956], [1240, 1300]], 'validModes': ['AM', 'FM', 'NFM', 'WFM'], 'validSteps': [5, 10, 12.5, 50, 100], 'validDelay': [1, 4], 'validChars': 16, 'validPriorityLockout': ['Y', 'N'] } minRange = str(inputValidation['channelRange'][0]) maxRange = str(inputValidation['channelRange'][1]) permissableFreqRanges = str(inputValidation['freqRange']) modeChoices = str(inputValidation['validModes']) stepChoices = str(inputValidation['validSteps']) delayChoices = str(inputValidation['validDelay']) maxChars = int(inputValidation['validChars']) validEntries = str(inputValidation['validPriorityLockout']) error = False ChannelList = [Channel(i) for i in range(maxChannel)] # list comprehension # ChannelList = [Channel(i) for i in range(maxChannel - 1)] # list comprehension # for i in range(maxChannel): # ChannelList.append(Channel(i)) menuChoices = """ Choose a menu item: 1: Create a new channel in internal memory 2: View channel in internal memory 3: Delete channel in internal memory 4: Write channels to csv 5: View all current channels in internal memory 6: Program scanner from csv file 7: View scanner channel 8: Write scanner channel 9: Read scanner bank(s) 10: Read all scanner channels 11. Open serial port 12. Close serial port 13. Scan 14. MAN (manual) key press 15: Exit """ quit = False while not quit: choice = inputCheck.inputException(menuChoices, 'integer', False, menuChoices, '', '') print('Menu choice is:', choice) if choice == 1: inputText = 'Enter the channel number to create. Range between: ' + minRange + ' and ' + maxRange channelNum = inputCheck.inputException(inputText, 'integer', False, '', 'channelRange', inputValidation) print('Channel is:', channelNum) inputText = 'Enter the frequency in MHz. Allowable ranges: ' + permissableFreqRanges freq = inputCheck.inputException(inputText, 'float', False, '', 'freqRange', inputValidation) print('Frequency is:', freq, 'MHz') inputText = 'Enter mode. Mode choices: ' + modeChoices mode = inputCheck.inputException(inputText, 'string', True, '', 'validModes', inputValidation) print('Mode is:', mode) inputText = 'Enter step. Step choices: ' + stepChoices step = inputCheck.inputException(inputText, 'float', False, '', 'validSteps', inputValidation) print('Step is:', step) inputText = 'Enter delay. Integer values between: ' + delayChoices delay = inputCheck.inputException(inputText, 'integer', False, '', 'validDelay', inputValidation) inputText = 'Enter alpha tag. Maximum characters: ' + str(maxChars) alphaTag = inputCheck.inputException(inputText, 'string', False, '', 'validChars', inputValidation) print('Alpha tag is:', alphaTag) inputText = 'Priority channel. Enter: ' + str(validEntries) priority = inputCheck.inputException(inputText, 'string', True, '', 'validPriorityLockout', inputValidation) inputText = 'Lockout channel? Enter:' + str(validEntries) lockout = inputCheck.inputException(inputText, 'string', True, '', 'validPriorityLockout', inputValidation) print('Lockout channel:', lockout) channel = Channel(channelNum, freq, mode, step, delay, alphaTag, priority, lockout) ChannelList.insert(channelNum - 1, channel) elif choice == 2: error = True while error: try: channelNum = int(input('Enter channel number\n')) error = False except ValueError: print('Please enter an integer between', minChannel, 'and', maxChannel, '!\n') # enhance to # check between min & max channels else: if channelNum < minChannel or channelNum > maxChannel: print('Channel out of range') else: channel = ChannelList[channelNum - 1] print('Properties of channel', channelNum) print('Frequency: ', channel.viewFreq()) print('Mode: ', channel.viewMode()) print('Step: ', channel.viewStep()) print('Delay: ', channel.viewDelay()) print('Alpha tag: ', channel.viewAlphaTag()) print('Priority: ', channel.viewPriority()) print('Lockout: ', channel.viewLockout()) elif choice == 3: channelNum = int(input('Enter channel number to delete\n')) channel = Channel(channelNum) ChannelList.insert(channelNum - 1, channel) elif choice == 4: write_csv(ChannelList) elif choice == 5: for i in range(maxChannel): print(i) channel = ChannelList[i] print(len(ChannelList)) channelNum = i + 1 print('Properties of channel', channelNum) print('Frequency: ', channel.viewFreq()) print('Mode: ', channel.viewMode()) print('Step: ', channel.viewStep()) print('Delay: ', channel.viewDelay()) print('Alpha tag: ', channel.viewAlphaTag()) print('Priority: ', channel.viewPriority()) print('Lockout: ', channel.viewLockout()) elif choice == 6: read_csv_program_scanner() elif choice == 7: channelNum = str(input('Enter scanner channel number\n')) scannerChannel = serialCommand(channelNum) print('Scanner data for channel', channelNum, 'is:', scannerChannel.viewScannerChannel(channelNum)) elif choice == 8: inputText = 'Enter the channel number to create. Range between: ' + minRange + ' and ' + maxRange channelNum = inputCheck.inputException(inputText, 'integer', False, '', 'channelRange', inputValidation) inputText = 'Enter the frequency in MHz. Allowable ranges: ' + permissableFreqRanges freq = inputCheck.inputException(inputText, 'float', True, '', 'freqRange', inputValidation) * 10000 # # eg format to use to speak to communicate with scanner: 243MHz = 2430000 inputText = 'Enter mode. Mode choices: ' + modeChoices mode = inputCheck.inputException(inputText, 'string', True, '', 'validModes', inputValidation) inputText = 'Enter step. Step choices: ' + stepChoices step = inputCheck.inputException(inputText, 'float', False, '', 'validSteps', inputValidation) inputText = 'Enter delay. Integer values between: ' + delayChoices delay = inputCheck.inputException(inputText, 'integer', False, '', 'validDelay', inputValidation) inputText = 'Enter alpha tag. Maximum characters: ' + str(maxChars) alphaTag = inputCheck.inputException(inputText, 'string', False, '', 'validChars', inputValidation) inputText = 'Priority channel. Enter: ' + str(validEntries) priority = inputCheck.inputException(inputText, 'string', True, '', 'validPriorityLockout', inputValidation) inputText = 'Lockoutchannel? Enter: ' + str(validEntries) lockout = inputCheck.inputException(inputText, 'string', True, '', 'validPriorityLockout', inputValidation) channel = Channel(channelNum, freq, mode, step, delay, alphaTag, priority, lockout) scannerChannel = serialCommand(channelNum) print(scannerChannel.programScannerChannel(channelNum, channel)) elif choice == 9: bankNum = int(input('Enter a bank number to read')) readBank(bankNum) elif choice == 10: readAll(maxChannel) elif choice == 11: # add exception handling for integer port numbers & permissable baud rates: 2400, 4800, # 9600, 19200... port = int(input('Enter COM port to connect to scanner')) portStr = 'COM' + str(port) baudrate = int(input('Enter baudrate')) connection = SerialPort.SerialConnection() print(connection.open_connection(portStr, baudrate, 1)) elif choice == 12: try: print(connection.close_connection()) except AttributeError: # COM port has not been opened yet... print('COM port has not been opened yet.') elif choice == 13: scan = '1' dummy_channel = serialCommand(scan) # scanner_mode = dummy_channel.checkMode() # no need to check scanner mode of operation... # if scanner_mode == '00': # scanner_mode = dummy_channel.manualMode() # print('Manual mode') # else: # scanner_mode = dummy_channel.scanMode() # print('Scan mode') dummy_channel.scanMode() elif choice == 14: scan = '1' dummy_channel = serialCommand(scan) # scanner_mode = dummy_channel.checkMode() # no need to check scanner mode of operation... # if scanner_mode == '00': # scanner_mode = dummy_channel.manualMode() # print('Manual mode') # else: # scanner_mode = dummy_channel.scanMode() # print('Scan mode') dummy_channel.manualMode() elif choice == 15: quit = True else: print('Invalid menu choice')
#! /usr/bin/env python3 import SerialPort if __name__ == '__main__': serial_port = SerialPort.SerialPort() serial_port.open() serial_port.transmit_binary([0x03]) # serial_port.send_help() serial_port.close()
class WindowUtama(QMainWindow): def __init__(self): super().__init__() self.__serverSuccessFlag = False self.__firstmessagefound = False self.__printfirstmessage = False self.pause = False self.count = 0 self.x_data = np.arange(DATA_LENGTH) self.freqs = FFTmodule.fftfreq(DATA_LENGTH, SAMPLE_INTERVAL)[:DATA_LENGTH // 2] self.magnitude = [0] * len(self.freqs) self.y_data = [0] * np.size(self.x_data) self.initServer() if self.__serverSuccessFlag: print(f"Server at {PORT}, {BAUDRATE} bps") self.initUi() self.resize(1000, 700) self.show() self.setTimer() else: exit(1) def initServer(self): self.UART = SerialPort(PORT, BAUDRATE) if self.UART.SUCCESS_OPEN: self.__serverSuccessFlag = True else: self.__serverSuccessFlag = False def initUi(self): self.setWindowTitle("Elektro - (Serial) Data Pysualization") # config main widget self.MainWidget = QWidget() self.MainWidgetLayout = QGridLayout() self.MainWidget.setLayout(self.MainWidgetLayout) # place the main widget in main window self.setCentralWidget(self.MainWidget) # INIT PLOTS ------------------------------------------------- self.List_of_Plots = [] self.TimePlot = FigureWidget(title=f"Time Domain", color=20, yRange=Y_LIMIT) self.FreqPlot = FigureWidget(title=f"Frequency Domain", color=40, yRange=[-20, 120]) self.List_of_Plots.append(self.TimePlot) self.List_of_Plots.append(self.FreqPlot) # INIT CHANNEL INFO ------------------------------------------ self.List_of_channels = [] #for n in range(2): # self.channel_n = ChannelWidget(title="Channel", num=n+1) # self.List_of_channels.append(self.channel_n) # ADD WIDGETS TO LAYOUT -------------------------------------- self.MainWidgetLayout.addWidget(self.List_of_Plots[0], 0, 0) self.MainWidgetLayout.addWidget(self.List_of_Plots[1], 1, 0) #self.MainWidgetLayout.addWidget(self.List_of_channels[0], 0, 2) #self.MainWidgetLayout.addWidget(self.List_of_channels[1], 1, 2) def setTimer(self): self.timer = QTimer() self.timer.timeout.connect(self.updateAll) self.timer.start(0) def updateAll(self): #self.start_time = time.time() try: data = self.UART.getNewData() if data.find(FIRST_MESSAGE): self.__firstmessagefound = True if not self.__printfirstmessage: print("Found first message!") self.__printfirstmessage = True if self.__firstmessagefound: data = float(data) * 5 / 1024 self.y_data.append(data) self.y_data.pop(0) self.magnitude = FFTmodule.fft(self.y_data) self.magnitude = 20 * np.log( np.abs(self.magnitude[:DATA_LENGTH // 2])) if not self.pause: self.List_of_Plots[0].PlotData(self.x_data, self.y_data) self.List_of_Plots[1].PlotData(self.freqs, self.magnitude) else: print("Paused!") except KeyboardInterrupt: print("\nKeyboard Interrupted!") try: self.UART.close() except: print("Serial port already closed") exit(1) except ValueError: pass