def main(): dn = DisplayNumber() dd = DigitDetection() ampel = MainAmpelerkennung() sRead = SerialRead() ser = Serial() process2 = multiprocessing.Process(target=ampel.detect_light) dn.start() dd.start() sRead.start() process2.start() finish = False while not finish: msg = sRead.getMsg() if "F" in str(msg): #if msg == "b'Finish'": finish = True number = dd.getNumber() print("number main: " + str(number)) if number == 0: number = randint(1, 5) print("number main definitive: " + str(number)) dd.cancel() dn.setNumber(number) dn.cancel() ser.sendText(str(number)) time.sleep(0.5) print("pink panzer finish")
def openPort(self, settings=None): if not settings: settings = self.ui.getPortSettings() if not settings["port"]: return False, u"错误的串口号" self.serial = Serial() self.connect(self.serial.qtobj, QtCore.SIGNAL(Serial.SIG_NEWDATA), self.onRecvData) self.connect(self.serial.qtobj, QtCore.SIGNAL(Serial.SIG_RECVEXCEPTION), self.onRecvException) ret, msg = self.serial.open(settings) return ret, msg
def chunkBlater(Input, CHUNK): """ __HELP__ type 'help(Serial)' in command window to get methods. """ elements = len(Input) packets = elements / CHUNK offset = elements - packets * CHUNK from time import sleep from Serial import Serial print "\nInput:\t" + str(Input) COMPORT = Serial() COMPORT.begin('COM6', 9600) block = [] received = [] if packets > 0: for i in range(0, packets): block = Input[i * CHUNK:(i + 1) * CHUNK] print block j = 0 for j in range(j, CHUNK): COMPORT.sprintln(block[j]) capture = COMPORT.sread() received.extend(capture) print "Packet Index:\t" + str(i) + "\tChunk Index:\t" + str( j) + "\tReceived:\t" + capture if offset > 0: block = Input[elements - offset:elements] print block k = 0 for k in range(k, offset): COMPORT.sprintln(block[k]) capture = COMPORT.sread() received.extend(capture) print "Offset Index:\t" + str(k) + "\tReceived:\t" + capture return distil(received)
def self_test(server): import Serial.Serial as ser try: while True: #val = ser.read() ser.read() data = json.dumps({"measure": "25"}) server.send_message_to_all(data) time.sleep(0.1) data = json.dumps({"measure": "35"}) server.send_message_to_all(data) time.sleep(0.1) except Exception as e: print(e.message)
def __init__(self, serialDev): self.logger = logging.getLogger('BleuettePi') self.serial = Serial() self.serial.connect(serialDev) self.mcp = MCP230XX(self.MCP_ADDRESS, 16) self.Servo = Servo.Servo(self.serial, fakemode=Config.FAKE_MODE) self.Servo.init() Servo.Servo_Trim.values = Data.Instance().get(['servo', 'trims']) Servo.Servo_Limit.values = Data.Instance().get(['servo', 'limits']) self.Analog = Analog(self.serial) self.Compass = BleuettePi_Compass() self.Accelerometer = BleuettePi_Accelerometer() self.GroundSensor = BleuettePi_GroundSensor(self.mcp) # Init mode GPIO.setmode(GPIO.BOARD) GPIO.setup(self.INTA, GPIO.IN) GPIO.setup(self.INTB, GPIO.IN) GPIO.setup(self.INTC, GPIO.IN) GPIO.setup(self.INTD, GPIO.IN) GPIO.add_event_detect(self.INTA, GPIO.RISING, callback=self.interrupt, bouncetime=300) GPIO.add_event_detect(self.INTB, GPIO.RISING, callback=self.interrupt, bouncetime=300) GPIO.add_event_detect(self.INTC, GPIO.RISING, callback=self.interrupt, bouncetime=300) GPIO.add_event_detect(self.INTD, GPIO.RISING, callback=self.interrupt, bouncetime=300) self.mcp.config(self.RESET_PIN, MCP230XX.OUTPUT) #self.mcp.pullup(self.RESET_PIN, True) self.mcp.output(self.RESET_PIN, 1)
def __init__(self, device): serial = Serial(device, 57600, 1) self._pins = [ DigitalPin("D10", "DIGITAL", 10, "INPUT"), DigitalPin("D11", "DIGITAL", 11, "INPUT"), ] super(YangBoard, self).__init__("Yang", serial, [])
def __init__(self, executable_path): super(Ui, self).__init__() ui_file = executable_path + QDir.separator() + 'Serial.ui' uic.loadUi(ui_file, self) self.serial = Serial() self.__signals() self.show()
class Serial_Manager: def __init__(self, Admission_Control): self.admission_control = Admission_Control self.serial = Serial(self) def write(self, data): if data: print("Writing on serial succes") else: print("Writing on serial fail") def handle_serial_request(self, data): print(data) if (data[Index.TYPE] == Request_Type.SENSOR): sensor = self.extract_sensor_data(data) self.admission_control.handle_new_sensor_request(sensor) else: interest = self.extract_interest_data(data) self.admission_control.handle_new_interest_request(interest) def extract_sensor_data(self, data): x = data[Index.X] y = data[Index.Y] radius = data[Index.RADIUS] return Sensor(x, y, radius) def extract_interest_data(self, data): x = data[Index.X] y = data[Index.Y] radius = data[Index.RADIUS] period = data[Index.PERIOD] expiry = data[Index.EXPIRY] return Interest(x, y, radius, period, expiry) def write(self, data): self.serial.write(data) def new_sensor_request(self, x, y): print("Serial recevied new sensor request with coordinates", x, y) sensor = Sensor(x, y) self.admission_control.handle_new_sensor_request(sensor) def new_interest_request(self, x, y, radius, period, expiracy): print("Serial recevied new interest request with coordinates", x, y) interest = Interest(x, y, radius, period, expiracy) self.admission_control.handle_new_interest_request(interest)
def __init__(self,device): serial = Serial(device,57600,1) self._pins = [ DigitalPin("D01","DIGITAL",1,"OUTPUT"), DigitalPin("D02","DIGITAL",1,"OUTPUT"), ] super(YinBoard,self).__init__("Yin",serial,self._pins)
def __init__(self, **kwargs): super().__init__(**kwargs) self.orientation = 'horizontal' # box dei widgets self.widget_box = BoxLayout() # self.serial è l'instanza principale di serial cui dovranno essere modificati gli attributi come port master angles self.serial = Serial() # contesto gl self.gl = glContext() # sliderBox è il widget contenente gli sliderAngles e i Label corrispondenti self.sliderBox = SliderAnglesBox(axis=RootWidget.axis) # master_cheker è il widget contenente delle checkerBox che permette di modificare master self.master_cheker = MasterChecker() # textInputPort è il text input dal quale viene modificata la porta in serial self.textInputPort = TextInputPort() # size dei widget self.textInputPort.size_hint = [1, .05] self.master_cheker.size_hint = [1, .05] self.sliderBox.size_hint = [1, .9] # aggiunta dei widget a widget_box self.widget_box.orientation = 'vertical' self.widget_box.add_widget(self.textInputPort) self.widget_box.add_widget(self.master_cheker) self.widget_box.add_widget(self.sliderBox) # size di widget_box e gl self.widget_box.size_hint = [.3, 1] self.gl.size_hint = [.7, 1] # aggiunta di widget_box e gl al BoxLayout self.add_widget(self.widget_box) self.add_widget(self.gl) Clock.schedule_interval(self.print_var_state, 1)
def sendSerial(self,command): """ Prepare and send a serial command to Serial class @param cmd string command """ wdg_retorno = self.get_wdg("txtRetorno") if(self.first_command): self.first_command=False buffer = gtk.TextBuffer() wdg_retorno.set_buffer(buffer) command = self.get_wdg("cbSerialCommand").get_active_text() for ip in self.stbip: ser = Serial(ip) cmds = serial_commands[command]['serial'] if (serial_commands[command]['complemento'] == False): retorno = ser.process(cmds) msg = "ip: %s\n"%(ip) self.show_message(msg + self.__make_serial_readable(command, retorno) + "\n") else: mb = MessageBox('error') mb.mostrar('Not implemented yet')
class Serial_Manager: def __init__(self): self.admission_control = None; self.serial = None def set_admission_control(self, admission_control): self.admission_control = admission_control self.serial = Serial() self.serial.set_serial_manager(self) def handle_serial_request(self, type, data): if(type == Request_Type.SENSOR): unpacked_data = struct.unpack('=3l1L', data) sensor = self.extract_sensor_data(unpacked_data) self.admission_control.handle_new_sensor_request(sensor) if(type == Request_Type.INTEREST): unpacked_data = struct.unpack('=3l1L2Q1i', data) interest = self.extract_interest_data(unpacked_data) self.admission_control.handle_new_interest_request(interest) if(type == Request_Type.CONFIG): unpacked_data = struct.unpack('=1L1I', data) self.admission_control.config(unpacked_data[0], unpacked_data[1]) def extract_sensor_data(self, data): x = data[Index.X] y = data[Index.Y] radius = data[Index.RADIUS] return Sensor(x, y, radius) def extract_interest_data(self, data): x = data[Index.X] y = data[Index.Y] radius = data[Index.RADIUS] period = data[Index.PERIOD] expiry = data[Index.EXPIRY] ref = data[Index.REF] return Interest(x, y, radius, period, expiry, ref) def write_response_message(self, result, interest_ref): self.write_header(1); self.write_msg(result, interest_ref) def write_header(self, times): header = bytes('^', 'ascii') + bytes(str(times), 'ascii') + bytes('$', 'ascii') self.serial.write(header) def write_msg(self, result, interest_ref): ref = bytes(str(interest_ref), 'ascii') msg = ref + b'X' + bytes(str(int(result)), 'ascii') self.serial.write(msg)
def updatePortComBox(self, isOpening=False): """ 更新串口列表, 暂不删除已不存在的端口 若没有已打开的串口则将最新发现的串口设置为当前串口 """ newCount = 0 for port in Serial.getActivePorts(): if self.port_comboBox.findText(port) > -1: continue self.port_comboBox.addItem(port) newCount += 1 if newCount == 0: return 0 if not isOpening: lastIndex = self.port_comboBox.count() - 1 if lastIndex > -1: self.port_comboBox.setCurrentIndex(lastIndex) return newCount
def __init__(self, mixed): self.serial = Serial() self.serial.connect(mixed) self.Servo = Servo(self.serial, fakemode = Config.FAKE_MODE) self.Analog = Analog(self.serial) self.Compass = BleuettePi_Compass() self.Accelerometer = BleuettePi_Accelerometer() self.GroundSensor = BleuettePi_GroundSensor() # Init mode GPIO.setmode(GPIO.BOARD) GPIO.setup(self.INTA, GPIO.IN) GPIO.setup(self.INTB, GPIO.IN) GPIO.setup(self.INTC, GPIO.IN) GPIO.setup(self.INTD, GPIO.IN) GPIO.add_event_detect(self.INTA, GPIO.RISING, callback = self.interrupt, bouncetime = 300) GPIO.add_event_detect(self.INTB, GPIO.RISING, callback = self.interrupt, bouncetime = 300) GPIO.add_event_detect(self.INTC, GPIO.RISING, callback = self.interrupt, bouncetime = 300) GPIO.add_event_detect(self.INTD, GPIO.RISING, callback = self.interrupt, bouncetime = 300)
def __init__(self, serialDev): self.logger = logging.getLogger('BleuettePi') self.serial = Serial() self.serial.connect(serialDev) self.mcp = MCP230XX(self.MCP_ADDRESS, 16) self.Servo = Servo.Servo(self.serial, fakemode = Config.FAKE_MODE) self.Servo.init() Servo.Servo_Trim.values = Data.Instance().get(['servo', 'trims']) Servo.Servo_Limit.values = Data.Instance().get(['servo', 'limits']) self.Analog = Analog(self.serial) self.Compass = BleuettePi_Compass() self.Accelerometer = BleuettePi_Accelerometer() self.GroundSensor = BleuettePi_GroundSensor(self.mcp) # Init mode GPIO.setmode(GPIO.BOARD) GPIO.setup(self.INTA, GPIO.IN) GPIO.setup(self.INTB, GPIO.IN) GPIO.setup(self.INTC, GPIO.IN) GPIO.setup(self.INTD, GPIO.IN) GPIO.add_event_detect(self.INTA, GPIO.RISING, callback = self.interrupt, bouncetime = 300) GPIO.add_event_detect(self.INTB, GPIO.RISING, callback = self.interrupt, bouncetime = 300) GPIO.add_event_detect(self.INTC, GPIO.RISING, callback = self.interrupt, bouncetime = 300) GPIO.add_event_detect(self.INTD, GPIO.RISING, callback = self.interrupt, bouncetime = 300) self.mcp.config(self.RESET_PIN, MCP230XX.OUTPUT) #self.mcp.pullup(self.RESET_PIN, True) self.mcp.output(self.RESET_PIN, 1)
<<<<<<< HEAD if Config.FAKE_MODE: obj = SerialFake else: obj = '/dev/ttyAMA0' ======= if True: obj = '/dev/ttyAMA0' fake = False else: obj = SerialFake fake = True >>>>>>> e9ffd7ef371450a29e24962357af5942710c8547 serial = Serial() serial.connect(obj) <<<<<<< HEAD servo = Servo(serial, fakemode = Config.FAKE_MODE) ======= servo = Servo(serial, fakemode = fake) >>>>>>> e9ffd7ef371450a29e24962357af5942710c8547 servo.init() #ServoSeq = Servo_Sequencer(servo) #ServoSeq.daemon = True; #ServoSeq.start() #sspeed = Servo_SpeedStep(servo) sspeed = Servo_SpeedDelay(servo)
data_list.append(line.strip().rstrip()) binary_data = ''.join(data_list) print('The statistical test of the Binary Expansion of SQRT(3)') print('2.1. Frequency Test:\t\t\t\t\t\t\t\t\t', FrequencyTest.monobit_test(binary_data[:1000000])) print('2.2. Block Frequency Test:\t\t\t\t\t\t\t\t', FrequencyTest.block_frequency(binary_data[:1000000])) print('2.3. Run Test:\t\t\t\t\t\t\t\t\t\t\t', RunTest.run_test(binary_data[:1000000])) print('2.4. Run Test (Longest Run of Ones): \t\t\t\t\t', RunTest.longest_one_block_test(binary_data[:1000000])) print('2.5. Binary Matrix Rank Test:\t\t\t\t\t\t\t', Matrix.binary_matrix_rank_text(binary_data[:1000000])) print('2.6. Discrete Fourier Transform (Spectral) Test: \t\t', SpectralTest.sepctral_test(binary_data[:1000000])) print('2.7. Non-overlapping Template Matching Test:\t\t\t', TemplateMatching.non_overlapping_test(binary_data[:1000000], '000000001')) print('2.8. Overlappong Template Matching Test: \t\t\t\t', TemplateMatching.overlapping_patterns(binary_data[:1000000])) print('2.9. Universal Statistical Test:\t\t\t\t\t\t', Universal.statistical_test(binary_data[:1000000])) print('2.10. Linear Complexity Test:\t\t\t\t\t\t\t', ComplexityTest.linear_complexity_test(binary_data[:1000000])) print('2.11. Serial Test:\t\t\t\t\t\t\t\t\t\t', Serial.serial_test(binary_data[:1000000])) print('2.12. Approximate Entropy Test:\t\t\t\t\t\t\t', ApproximateEntropy.approximate_entropy_test(binary_data[:1000000])) print('2.13. Cumulative Sums (Forward):\t\t\t\t\t\t', CumulativeSums.cumulative_sums_test(binary_data[:1000000], 0)) print('2.13. Cumulative Sums (Backward):\t\t\t\t\t\t', CumulativeSums.cumulative_sums_test(binary_data[:1000000], 1)) result = RandomExcursions.random_excursions_test(binary_data[:1000000]) print('2.14. Random Excursion Test:') print('\t\t STATE \t\t\t xObs \t\t\t\t P-Value \t\t\t Conclusion') for item in result: print('\t\t', repr(item[0]).rjust(4), '\t\t', item[1], '\t\t', repr(item[2]).ljust(14), '\t\t', (item[3] >= 0.01)) result = RandomExcursions.variant_test(binary_data[:1000000]) print('2.15. Random Excursion Variant Test:\t\t\t\t\t\t') print('\t\t STATE \t\t COUNTS \t\t\t P-Value \t\t Conclusion')
def execute(self): print('Execute') input = '' self.__test_results = [(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),()] if (not len(self.__binary_data.get().strip()) == 0) and (not len(self.__file_name.get()) == 0): messagebox.showwarning("Warning", 'You can only either input the binary data or read the data from from the file.') elif not len(self.__binary_data.get().strip()) == 0: print('User Input') input = self.__binary_data.get() elif not len(self.__file_name.get()) == 0: print('File Input') print(self.__file_name.get()) handle = open(self.__file_name.get()) data_list = [] for line in handle: data_list.append(line.strip().rstrip()) input = ''.join(data_list) else: messagebox.showwarning("Warning", 'You must enter either input data or file name to read before you can execute the test.') if len(input) > 1000000: input = input[:1000000] checked = False for item in self.__chb_var: if item.get() == 1: checked = True break if not checked: messagebox.showwarning("Warning", "you must select a test to execute") else: if self.__chb_var[0].get() == 1: print(self.__test_type[0], 'selected.') result = ft.monobit_test(input) self.__monobit_p_value.set(result[0]) self.__monobit_result.set(self.get_conclusion(result[1])) self.__test_results[0] = result if self.__chb_var[1].get() == 1: print(self.__test_type[1], 'selected.') result = ft.block_frequency(input) self.__block_p_value.set(result[0]) self.__block_result.set(self.get_conclusion(result[1])) self.__test_results[1] = result if self.__chb_var[2].get() == 1: print(self.__test_type[2], 'selected.') result = rt.run_test(input) self.__run_p_value.set(result[0]) self.__run_result.set(self.get_conclusion(result[1])) self.__test_results[2] = result if self.__chb_var[3].get() == 1: print(self.__test_type[3], 'selected.') result = rt.longest_one_block_test(input) self.__long_run_p_value.set(result[0]) self.__long_run_result.set(self.get_conclusion(result[1])) self.__test_results[3] = result if self.__chb_var[4].get() == 1: print(self.__test_type[4], 'selected.') result = mt.binary_matrix_rank_text(input) self.__matrix_p_value.set(result[0]) self.__matrix_result.set(self.get_conclusion(result[1])) self.__test_results[4] = result if self.__chb_var[5].get() == 1: print(self.__test_type[5], 'selected.') result = st.sepctral_test(input) self.__spectral_p_value.set(result[0]) self.__spectral_result.set(self.get_conclusion(result[1])) self.__test_results[5] = result if self.__chb_var[6].get() == 1: print(self.__test_type[6], 'selected.') result = tm.non_overlapping_test(input) self.__non_overlapping_p_value.set(result[0]) self.__non_overlapping_result.set(self.get_conclusion(result[1])) self.__test_results[6] = result if self.__chb_var[7].get() == 1: print(self.__test_type[7], 'selected.') result = tm.overlapping_patterns(input) self.__overlapping_p_value.set(result[0]) self.__overlapping_result.set(self.get_conclusion(result[1])) self.__test_results[7] = result if self.__chb_var[8].get() == 1: print(self.__test_type[8], 'selected.') result = ut.statistical_test(input) self.__statistical_p_value.set(result[0]) self.__statistical_result.set(self.get_conclusion(result[1])) self.__test_results[8] = result if self.__chb_var[9].get() == 1: print(self.__test_type[9], 'selected.') result = ct.linear_complexity_test(input) self.__linear_p_value.set(result[0]) self.__linear_result.set(self.get_conclusion(result[1])) self.__test_results[9] = result if self.__chb_var[10].get() == 1: print(self.__test_type[10], 'selected.') result = serial.serial_test(input) self.__serial_p_value_01.set(result[0][0]) self.__serial_p_result_01.set(self.get_conclusion(result[0][1])) self.__serial_p_value_02.set(result[1][0]) self.__serial_p_result_02.set(self.get_conclusion(result[1][1])) self.__test_results[10] = result if self.__chb_var[11].get() == 1: print(self.__test_type[11], 'selected.') result = aet.approximate_entropy_test(input) self.__entropy_p_value.set(result[0]) self.__entropy_result.set(self.get_conclusion(result[1])) self.__test_results[11] = result if self.__chb_var[12].get() == 1: print(self.__test_type[12], 'selected.') result = cst.cumulative_sums_test(input, 0) self.__cusum_f_p_value.set(result[0]) self.__cusum_f_result.set(self.get_conclusion(result[1])) self.__test_results[12] = result if self.__chb_var[13].get() == 1: print(self.__test_type[13], 'selected.') result = cst.cumulative_sums_test(input, 1) self.__cusum_r_p_value.set(result[0]) self.__cusum_r_result.set(self.get_conclusion(result[1])) self.__test_results[13] = result if self.__chb_var[14].get() == 1: print(self.__test_type[14], 'selected.') self.__excursion_result = ret.random_excursions_test(input) for item in self.__excursion_result: if self.__state_01.get() == item[0]: self.__xObs_chi_01.set(item[2]) self.__p_value_01.set(item[3]) self.__conclusion_01.set(self.get_conclusion(item[4])) self.__test_results[14] = self.__excursion_result if self.__chb_var[15].get() == 1: print(self.__test_type[15], 'selected.') __variant_result = ret.variant_test(input) self.__variant_result = ret.variant_test(input) for item in self.__variant_result: print(item) if self.__state_02.get() == item[0]: self.__count.set(item[2]) self.__p_value_02.set(item[3]) self.__conclusion_02.set(self.get_conclusion(item[4])) self.__test_results[15] = self.__variant_result
from Serial import Serial s = Serial(debug=True) for i in s.devices: if "hmp2030" in s.devices[i].device_id.lower(): while 1: s.devices[0].write("SYSTem:BEEPer[:IMMediate]")
from Database import Database import json import pigpio GPIO.setmode(GPIO.BCM) # INIT THE APP app = Flask(__name__) # SETTINGS CORS(app) app.config['SECRET_KEY'] = 'Secret!' socket = SocketIO(app) conn = Database(app=app, user='******', password='******', db='mydb') Serial() CheckPawns(socket, conn) ledColor = '00FFFF' ledMode = 'auto' ledPins = [5, 17, 27] piGPIO = pigpio.pi() for i in range(3): piGPIO.set_PWM_frequency(ledPins[i], 500) piGPIO.set_PWM_dutycycle(ledPins[i], 0) @socket.on('connect') def connect():
import cv2 import time from TrafficLightDetection import * from Serial import Serial print('Start Capture') # initialize serial connection ser = Serial() # start the video capture camera = cv2.VideoCapture(0) # initialize variables for traffic light detection # loop: initial state TRUE to run the loop and FALSE to stop the loop # traffic_light: initial state red = FALSE and green = TRUE # emergency_counter: a counter to prevent the pink panzer form never starting # even if no signal from the traffic light can be detected loop = True traffic_light = 'ps' emergency_counter = 0 # looping while video capture is active if (camera.isOpened()): while (loop): # if the counter reaches 500, the go siganl will be given # regardless of the traffic light if (emergency_counter < 500): print(traffic_light)
def __init__(self, Admission_Control): self.admission_control = Admission_Control self.serial = Serial(self)
RunTest.longest_one_block_test(binary_data[:1000000])) print('2.05. Binary Matrix Rank Test:\t\t\t\t\t\t', Matrix.binary_matrix_rank_text(binary_data[:1000000])) print('2.06. Discrete Fourier Transform (Spectral) Test:\t', SpectralTest.sepctral_test(binary_data[:1000000])) print( '2.07. Non-overlapping Template Matching Test:\t\t', TemplateMatching.non_overlapping_test(binary_data[:1000000], '000000001')) print('2.08. Overlappong Template Matching Test: \t\t\t', TemplateMatching.overlapping_patterns(binary_data[:1000000])) print('2.09. Universal Statistical Test:\t\t\t\t\t', Universal.statistical_test(binary_data[:1000000])) print('2.10. Linear Complexity Test:\t\t\t\t\t\t', ComplexityTest.linear_complexity_test(binary_data[:1000000])) print('2.11. Serial Test:\t\t\t\t\t\t\t\t\t', Serial.serial_test(binary_data[:1000000])) print('2.12. Approximate Entropy Test:\t\t\t\t\t\t', ApproximateEntropy.approximate_entropy_test(binary_data[:1000000])) print('2.13. Cumulative Sums (Forward):\t\t\t\t\t', CumulativeSums.cumulative_sums_test(binary_data[:1000000], 0)) print('2.13. Cumulative Sums (Backward):\t\t\t\t\t', CumulativeSums.cumulative_sums_test(binary_data[:1000000], 1)) result = RandomExcursions.random_excursions_test(binary_data[:1000000]) print('2.14. Random Excursion Test:') print('\t\t STATE \t\t\t xObs \t\t\t\t P-Value \t\t\t Conclusion') for item in result: print('\t\t', repr(item[0]).rjust(4), '\t\t', item[2], '\t\t', repr(item[3]).ljust(14), '\t\t', (item[4] >= 0.01))
def set_admission_control(self, admission_control): self.admission_control = admission_control self.serial = Serial() self.serial.set_serial_manager(self)
class BleuettePi(Serial): INTA = 26 INTB = 15 INTC = 22 INTD = 12 STATUS_MAX_CURRENT_REACHED = 0 MCP_ADDRESS = 0x20 RESET_PIN = 14 serial = None mcp = None Servo = None Compass = None Accelerometer = None GroundSensor = None def __init__(self, serialDev): self.logger = logging.getLogger('BleuettePi') self.serial = Serial() self.serial.connect(serialDev) self.mcp = MCP230XX(self.MCP_ADDRESS, 16) self.Servo = Servo.Servo(self.serial, fakemode=Config.FAKE_MODE) self.Servo.init() Servo.Servo_Trim.values = Data.Instance().get(['servo', 'trims']) Servo.Servo_Limit.values = Data.Instance().get(['servo', 'limits']) self.Analog = Analog(self.serial) self.Compass = BleuettePi_Compass() self.Accelerometer = BleuettePi_Accelerometer() self.GroundSensor = BleuettePi_GroundSensor(self.mcp) # Init mode GPIO.setmode(GPIO.BOARD) GPIO.setup(self.INTA, GPIO.IN) GPIO.setup(self.INTB, GPIO.IN) GPIO.setup(self.INTC, GPIO.IN) GPIO.setup(self.INTD, GPIO.IN) GPIO.add_event_detect(self.INTA, GPIO.RISING, callback=self.interrupt, bouncetime=300) GPIO.add_event_detect(self.INTB, GPIO.RISING, callback=self.interrupt, bouncetime=300) GPIO.add_event_detect(self.INTC, GPIO.RISING, callback=self.interrupt, bouncetime=300) GPIO.add_event_detect(self.INTD, GPIO.RISING, callback=self.interrupt, bouncetime=300) self.mcp.config(self.RESET_PIN, MCP230XX.OUTPUT) #self.mcp.pullup(self.RESET_PIN, True) self.mcp.output(self.RESET_PIN, 1) def interrupt(self, index): if index == self.INTA: self.logger.info("Interrupt from GPA") elif index == self.INTB: self.logger.info("Interrupt from GPB") elif index == self.INTC: self.logger.info("Interrupt from RTC") elif index == self.INTD: self.logger.info("Interrupt from PIC") self.getStatus() ''' def setCurrentAlarmLevel(self, level): print "Level", level if level >= 1024: raise Exception('Max current alarm level is 1024 !') data = struct.pack("@i", level) level = [ data[0], data[1] ] return self.command(BPi_Cmd.SET_MAX, level) ''' # Hard reset def reset(self): self.mcp.output(self.RESET_PIN, 0) time.sleep(1) self.mcp.output(self.RESET_PIN, 1) time.sleep(1) self.Servo.init() def getStatus(self): self.serial.write(self.HEADER) self.serial.write(BPi_Cmd.STATUS) status = self.serial.read(1) if ord(status) & (1 << self.STATUS_MAX_CURRENT_REACHED): self.logger.warning("Max current reached !") return status
old_data = data # print("not movement") # ui.textBrowser.setText("") if __name__ == '__main__': net = nn.loadFromFile("Neural_Networks/.neuralnetwork.pkl") old_gesture = None old_vector = 0 old_data = None listening = False serial = Serial("/dev/ttyUSB0") # reset Arduino serial.setDTR(False) serial.flushInput() serial.setDTR(True) serial.start() # tick = perf_counter() # serial.serialEvent.connect(shift_frame) # serial.serialEvent.connect(print) serial.serialEvent.connect(test_movement) frame = deque(maxlen=360) app = QtWidgets.QApplication(sys.argv)
def detect_light(self): print('Start Capture') # initialize serial connection ser = Serial() # start the video capture camera = cv2.VideoCapture(1) # Load an image #frame = cv2.imread('images/ampel_red.png') #frame = cv2.imread('images/ampel_green.png') #frame = cv2.imread('images/color_gradient.png') # Load a video #camera = cv2.VideoCapture('videos/AmpelTest.mp4') # initialize variables for traffic light detection # loop: initial state TRUE to run the loop and FALSE to stop the loop # traffic_light: initial state red = FALSE and green = TRUE # emergency_counter: a counter to prevent the pink panzer form never starting # even if no signal from the traffic light can be detected loop = True traffic_light = 's' debug_mode = False begin = datetime.datetime.now() begin = begin+30 # looping while video capture is active if (camera.isOpened()): while (loop): #Auskommentiert durch Lukas 30.06.2017 #print (traffic_light) # grab the current frame _, frame = camera.read() # prepare the frame for color detection prepped_frame = frame_prep(frame) # set the color for color detection and create # a mask by checking for red and green traffic lights mask = color_detection(prepped_frame, 'green') # find contours in the mask and initialize the current # (x, y) center of the ball contour = contour_detection(mask) # give the go-signal when a matching contour was found traffic_light = go_time(contour) # stop the loop if it is go time if (traffic_light == 'g'): print (traffic_light) print ('Green Light detected') loop = False if (debug_mode): cv2.imshow('frame', frame) cv2.imshow('prepped_frame', prepped_frame) cv2.imshow('mask', mask) if cv2.waitKey(1) & 0xFF == ord('q'): break now = datetime.datetime.now() if now > begin: loop = False else: print('No Video Capture detected') print ('Go Time') camera.release() cv2.destroyAllWindows() ser.sendText(traffic_light)
def _init_serial(self): ser = Serial("98:D3:32:70:8B:76") return ser
rainbowHandler = RainbowLoggingHandler(sys.stdout) formatter = logging.Formatter( "%(asctime)s - %(name)s - %(levelname)s - %(message)s") rainbowHandler.setFormatter(formatter) logger.addHandler(rainbowHandler) logger.setLevel(logging.DEBUG) if True: obj = '/dev/ttyAMA0' fake = False else: obj = SerialFake fake = True serial = Serial() serial.connect(obj) servo = Servo(serial, fakemode=fake) #Servo.init() #ServoSeq = Servo_Sequencer(servo) #ServoSeq.daemon = True; #ServoSeq.start() engine = Servo_Engine(servo) engine.start() SPEED = 1 CONSIGNE = 170
from USBTMC import USBTMC from GPIB import GPIB from Serial import Serial import time import TermOut.Logging as Logging usb = USBTMC() gpib = GPIB() serial = Serial() devices = [] for i in usb.devices: devices.append(usb.devices[i]) for i in gpib.devices: devices.append(gpib.devices[i]) for i in serial.devices: devices.append(serial.devices[i]) print(devices) while 1: k = 0 for i in devices: Logging.info(i.get("*IDN?").rstrip()) k += 1 Logging.header("Got answer from %s devices." % str(k)) time.sleep(2)
def detect_light(self): print('Start Capture') # initialize serial connection ser = Serial() # start the video capture camera = cv2.VideoCapture(1) # Load an image #frame = cv2.imread('images/ampel_red.png') #frame = cv2.imread('images/ampel_green.png') #frame = cv2.imread('images/color_gradient.png') # Load a video #camera = cv2.VideoCapture('videos/AmpelTest.mp4') # initialize variables for traffic light detection # loop: initial state TRUE to run the loop and FALSE to stop the loop # traffic_light: initial state red = FALSE and green = TRUE # emergency_counter: a counter to prevent the pink panzer form never starting # even if no signal from the traffic light can be detected loop = True traffic_light = 's' emergency_counter = 0 # looping while video capture is active if (camera.isOpened()): while (loop): # if the counter reaches 200, the go siganl will be given # regardless of the traffic light if (emergency_counter < 200): print(traffic_light) # grab the current frame _, frame = camera.read() # prepare the frame for color detection prepped_frame = frame_prep(frame) # set the color for color detection and create # a mask by checking for red and green traffic lights mask = color_detection(prepped_frame, 'green') # find contours in the mask and initialize the current # (x, y) center of the ball contour = contour_detection(mask) # give the go-signal when a matching contour was found traffic_light = go_time(contour) # stop the loop if it is go time if (traffic_light == 'g'): print(traffic_light) print('Green Light detected') loop = False # increase the emergency counter emergency_counter += 1 cv2.imshow('frame', frame) cv2.imshow('prepped_frame', prepped_frame) cv2.imshow('mask', mask) if cv2.waitKey(1) & 0xFF == ord('q'): break else: # stop the loop if the emergency counter reaches 100 # and set the traffic light variable accordingly traffic_light = 'g' loop = False print(traffic_light) print('Emergency Loop exeeded') cv2.imshow('frame', frame) cv2.imshow('prepped_frame', prepped_frame) cv2.imshow('mask', mask) if cv2.waitKey(1) & 0xFF == ord('q'): break else: print('No Video Capture detected') print('Go Time') camera.release() cv2.destroyAllWindows() ser.sendText(traffic_light)
isWorkingWithModem = True isModemRequired = True isACKwaiting = False if REAL_TEST: #subprocess.call(["sudo","pigpiod"]) pi = pigpio.pi() #if not pi.connected: # exit() baudrate = int(Config.get('BAUDRATE')) txPin = int(Config.get('TX_PIN')) rxPin = int(Config.get('RX_PIN')) modems = Serial(baudrate, txPin, rxPin) ph_numb = Config.get('ALRM_NUMBS').split(",") #список телефонов для оповещения fullInfo = '' # lastUsedPhNumb = '' # телефон с которого пришёл запрос modem_alive = False #флаг признака модема в рабочем состоянии error_try = 0 modem_try = 0 MODEM_PWR_PIN = int(Config.get('MODEM_PWR_PIN')) if REAL_TEST: pi.set_mode(MODEM_PWR_PIN, pigpio.OUTPUT)
class BleuettePi(Serial): INTA = 26 INTB = 15 INTC = 22 INTD = 12 STATUS_MAX_CURRENT_REACHED = 0 MCP_ADDRESS = 0x20 RESET_PIN = 14 serial = None mcp = None Servo = None Compass = None Accelerometer = None GroundSensor = None def __init__(self, serialDev): self.logger = logging.getLogger('BleuettePi') self.serial = Serial() self.serial.connect(serialDev) self.mcp = MCP230XX(self.MCP_ADDRESS, 16) self.Servo = Servo.Servo(self.serial, fakemode = Config.FAKE_MODE) self.Servo.init() Servo.Servo_Trim.values = Data.Instance().get(['servo', 'trims']) Servo.Servo_Limit.values = Data.Instance().get(['servo', 'limits']) self.Analog = Analog(self.serial) self.Compass = BleuettePi_Compass() self.Accelerometer = BleuettePi_Accelerometer() self.GroundSensor = BleuettePi_GroundSensor(self.mcp) # Init mode GPIO.setmode(GPIO.BOARD) GPIO.setup(self.INTA, GPIO.IN) GPIO.setup(self.INTB, GPIO.IN) GPIO.setup(self.INTC, GPIO.IN) GPIO.setup(self.INTD, GPIO.IN) GPIO.add_event_detect(self.INTA, GPIO.RISING, callback = self.interrupt, bouncetime = 300) GPIO.add_event_detect(self.INTB, GPIO.RISING, callback = self.interrupt, bouncetime = 300) GPIO.add_event_detect(self.INTC, GPIO.RISING, callback = self.interrupt, bouncetime = 300) GPIO.add_event_detect(self.INTD, GPIO.RISING, callback = self.interrupt, bouncetime = 300) self.mcp.config(self.RESET_PIN, MCP230XX.OUTPUT) #self.mcp.pullup(self.RESET_PIN, True) self.mcp.output(self.RESET_PIN, 1) def interrupt(self, index): if index == self.INTA: self.logger.info("Interrupt from GPA") elif index == self.INTB: self.logger.info("Interrupt from GPB") elif index == self.INTC: self.logger.info("Interrupt from RTC") elif index == self.INTD: self.logger.info("Interrupt from PIC") self.getStatus() ''' def setCurrentAlarmLevel(self, level): print "Level", level if level >= 1024: raise Exception('Max current alarm level is 1024 !') data = struct.pack("@i", level) level = [ data[0], data[1] ] return self.command(BPi_Cmd.SET_MAX, level) ''' # Hard reset def reset(self): self.mcp.output(self.RESET_PIN, 0) time.sleep(1) self.mcp.output(self.RESET_PIN, 1) time.sleep(1) self.Servo.init() def getStatus(self): self.serial.write(self.HEADER) self.serial.write(BPi_Cmd.STATUS) status = self.serial.read(1) if ord(status) & (1 << self.STATUS_MAX_CURRENT_REACHED): self.logger.warning("Max current reached !") return status
class MainWindow(QtGui.QMainWindow): def __init__(self, parent=None): QtGui.QMainWindow.__init__(self) self.autoSend = False # TODO: read config self.incPrefix = False # TODO: read config self.incStartVal = 0 self.autoSendTimes = 0 self.ui = Ui_Proxy() self.flags = {"__isopen__": False, "__datatype__": config.ASCII_TYPE} self.ui.setupUi(self) self.ui.setupWidget(self) self.tipWidget = TipWidget(self) self.setupSignals() self.filterParent = re.compile("") def closeEvent(self, e): if self.flags["__isopen__"]: self.serial.terminate() e.accept() config.saveSettings(self.ui.getCurrentConfigDict()) def setupSignals(self): self.ui.open_pushButton.clicked.connect(self.onOpenPort) self.ui.updatePort_pushButton.clicked.connect(self.onUpdatePort) self.ui.send_pushButton.clicked.connect(self.onSendData) self.ui.clear_pushButton.clicked.connect( self.ui.recv_TextBrowser.clear) self.ui.autoSend_checkBox.stateChanged.connect(self.onAutoSend) self.ui.sendType_comboBox.currentIndexChanged.connect( self.ui.onSendTypeChanged) self.ui.inc_checkBox.stateChanged.connect( self.onIncCheckBoxStateChanged) self.ui.resetStartVal_pushButton.clicked.connect(self.resetIncStartVal) self.ui.clearLcdNumber_pushButton.clicked.connect( self.ui.clearLcdNumber) self.ui.about_action.triggered.connect(self.onAbout) self.ui.settings_action.triggered.connect(self.onSettings) self.ui.saveData_action.triggered.connect(self.onSaveData) def openPort(self, settings=None): if not settings: settings = self.ui.getPortSettings() if not settings["port"]: return False, u"错误的串口号" self.serial = Serial() self.connect(self.serial.qtobj, QtCore.SIGNAL(Serial.SIG_NEWDATA), self.onRecvData) self.connect(self.serial.qtobj, QtCore.SIGNAL(Serial.SIG_RECVEXCEPTION), self.onRecvException) ret, msg = self.serial.open(settings) return ret, msg def closePort(self): self.serial.terminate() self.ui.onPortClosed() self.flags["__isopen__"] = False def onOpenPort(self): if self.flags["__isopen__"]: return self.closePort() self.ui.onPortOpening() ret, msg = self.openPort() if not ret: QtGui.QMessageBox.critical(self, u"打开串口失败", u"设备正忙或已移除, 请重新尝试打开") else: self.flags["__isopen__"] = True self.serial.start() self.ui.onPortOpened() def onUpdatePort(self): newCount = self.ui.updatePortComBox(self.flags["__isopen__"]) self.tipWidget.makeInfoText(u"更新了 " + ` newCount ` + u" 个串口") def onSendData(self): if not self.flags["__isopen__"]: return data, _type = self.ui.getDataAndType() ret, msg = util.checkData(data, _type) if not ret: QtGui.QMessageBox.critical(self, "Error", u"%s" % msg) return if self.autoSend: self.timer = QtCore.QTimer() self.timer.timeout.connect(self.onTimeout) self.timer.start(self.ui.getAutoSendInterval()) self.ui.onAutoSendStarted() else: self.sendData() def sendData(self): data, _type = self.ui.getDataAndType() ret, buff = DataManager.getDataToSend(data, _type, self.ui.getAsciiTail()) if not ret: QtGui.QMessageBox.critical(self, u"发送数据错误", buff) return # 以PB协议模式发送时, 在收发区显示协议编码后的HEX if _type == config.ASCII_TYPE: if self.incPrefix: buff = ` self.incStartVal ` + buff data = ` self.incStartVal ` + data self.incStartVal += 1 self.ui.onSendData(unicode(data, "utf-8"), _type) try: self.serial.send(buff, _type) self.ui.addTXBytesNumber(len(buff)) except Exception as e: if self.autoSend: self.ui.autoSend_checkBox.setChecked(False) QtGui.QMessageBox.critical(self, "", u"发送失败, 可能串口已关闭") def onRecvData(self, nData): self.ui.addRXBytesNumber(len(nData)) text = DataManager.getVisualizedData(nData, self.ui.getRecvType()) if self.filterParent.match(text): self.ui.onRecvData(text) def onRecvException(self): QtGui.QMessageBox.critical(self, u"接收异常", u"串口设备故障或已移除\n请先排查问题,再尝试请新打开串口") self.onOpenPort() # TODO: 更新串口列表 def onAutoSend(self, status): self.autoSend = status == 2 self.ui.onAutoSend(status) self.autoSendTimes = 0 def onIncCheckBoxStateChanged(self, status): self.incPrefix = status == 2 def resetIncStartVal(self): self.incStartVal = 0 def onTimeout(self): if not self.autoSend: self.timer.stop() del self.timer return self.sendData() self.autoSendTimes += 1 self.ui.updateAutoSendTimes(self.autoSendTimes) def onSettings(self): value, ret = QtGui.QInputDialog.getInt(self, u"数据合并", u"合并指定时间(毫秒)内收到的数据 ", config.mergeInterval) if not ret: return if value > 20: ret = QtGui.QMessageBox.question(self, u"提醒", u"过长的时间可能会造成数据丢失", u"仍要设置", u"放弃设置") if ret != 0: return if value >= 0: config.mergeInterval = value def onSaveData(self): fileName = QtGui.QFileDialog.getSaveFileName(self, u"保存数据", "", "Data File(*.txt)") if fileName == "": return if not util.writeToFile(fileName, self.ui.getRecvWidgetContent()): QtGui.QMessageBox.critical(self, u"错误", u"保存文件失败") def onAbout(self): QtGui.QMessageBox.information(self, u"关于", config.ABOUT_MESSAGE)
from Serial import Serial from RCRFile import File from Analytics import Analytics #Don't forget to update the serial port location!! serial_port = Serial('COM8') header = ["time", "response"] data_file = File(header=header) serial_port.listen_and_log(data_file) Analytics.sr_test(data_file) data_file.close() try: while True: pass except KeyboardInterrupt: pass
class BleuettePi(Serial): INTA = 26 INTB = 15 INTC = 22 INTD = 12 STATUS_MAX_CURRENT_REACHED = 0 serial = None Compass = None Accelerometer = None GroundSensor = None def __init__(self, mixed): self.serial = Serial() self.serial.connect(mixed) self.Servo = Servo(self.serial, fakemode = Config.FAKE_MODE) self.Analog = Analog(self.serial) self.Compass = BleuettePi_Compass() self.Accelerometer = BleuettePi_Accelerometer() self.GroundSensor = BleuettePi_GroundSensor() # Init mode GPIO.setmode(GPIO.BOARD) GPIO.setup(self.INTA, GPIO.IN) GPIO.setup(self.INTB, GPIO.IN) GPIO.setup(self.INTC, GPIO.IN) GPIO.setup(self.INTD, GPIO.IN) GPIO.add_event_detect(self.INTA, GPIO.RISING, callback = self.interrupt, bouncetime = 300) GPIO.add_event_detect(self.INTB, GPIO.RISING, callback = self.interrupt, bouncetime = 300) GPIO.add_event_detect(self.INTC, GPIO.RISING, callback = self.interrupt, bouncetime = 300) GPIO.add_event_detect(self.INTD, GPIO.RISING, callback = self.interrupt, bouncetime = 300) def interrupt(self, index): if index == self.INTA: print "Interrupt from GPA" elif index == self.INTB: print "Interrupt from GPB" elif index == self.INTC: print "Interrupt from RTC" elif index == self.INTD: print "Interrupt from PIC !" self.getStatus() ''' def setCurrentAlarmLevel(self, level): print "Level", level if level >= 1024: raise Exception('Max current alarm level is 1024 !') data = struct.pack("@i", level) level = [ data[0], data[1] ] return self.command(BPi_Cmd.SET_MAX, level) ''' def getStatus(self): self.serial.write(self.HEADER) self.serial.write(BPi_Cmd.STATUS) status = self.serial.read(1) if ord(status) & (1 << self.STATUS_MAX_CURRENT_REACHED): print "Max current reached !" return status