Exemplo n.º 1
1
 def openbci_id(self, serial):
   line = ''
   #Wait for device to send data
   time.sleep(2)
   
   if serial.inWaiting():
     line = ''
     c = ''
    #Look for end sequence $$$
     while '$$$' not in line:
       c = serial.read().decode('utf-8')
       line += c
     if "OpenBCI" in line:
       return True
   return False
Exemplo n.º 2
0
def send_command(serial,
                 command,
                 human,
                 expected_response=None,
                 crlf=True,
                 waittime=1000):
    '''Sends a command to the device.'''

    # flush the read buffer
    serial.read(serial.inWaiting())

    print human
    print "<<< " + command
    serial.write(command)
    if crlf:
        serial.write("\r\n")

    time.sleep(waittime / 1000)

    if expected_response:
        n = max([serial.inWaiting(), len(expected_response)])
        #print n
        data = serial.read(n)
        #print data
        if expected_response in data:
            print ">>> OK"
        else:
            print "<<< " + command
            print ">>> ERROR: " + data
Exemplo n.º 3
0
def modem_terminal(serial, string, timeout):
    serial.flushInput()
    serial.write(string)
    while timeout > 0:
        if serial.inWaiting() > 0:
            sys.stdout.write(serial.read(serial.inWaiting()))
        time.sleep(0.001)
        timeout = timeout - 1
    print ""
Exemplo n.º 4
0
def modem_terminal(serial,string,timeout):
	serial.flushInput()
	serial.write(string)
	while timeout>0:
		if serial.inWaiting()>0:
			sys.stdout.write(serial.read(serial.inWaiting()))
		time.sleep(0.001)
		timeout=timeout-1
	print ""
Exemplo n.º 5
0
def readSerial(threadName, delay):
    s = ""
    while True:
        if serial.inWaiting() != 0:
            c = serial.read()

            if (c == 'U'):
                global relock
                relock = 1
            if (c == 'S' or c == 'I'):
                global sendPin
                sendPin = 1

            if (c == '\n'):
                print "[%7s] %s" % (threadName, s)
                #                if(s == "Enter Pin:"):
                #                    print "in sendpin"
                #                    global sendPin
                #                    sendPin = 1
                if (s == "Unlocked"):
                    print "In unlocked"
                    global relock
                    relock = 1
                s = ""
            else:
                s += c
        else:
            time.sleep(0.01)
Exemplo n.º 6
0
def getGPS():
    out = ''
    ynDATA = False
    dataE1, dataE2, dataE3, dataE4 = 0, 0, 0, 0
    dataN1, dataN2, dataN3, dataN4 = 0, 0, 0, 0

    try:
        while (serial.inWaiting()):
            out = str(serial.readline().decode('utf-8'))

    except:
        pass

    if out != '':
        gpsdata = out.split(",")
        print(out)

        if (gpsdata[0] == "$GPGGA"):
            dataE = gpsdata[4]
            dataN = gpsdata[2]
            if (len(dataE) >= 10):
                dataE1, dataE2, dataE3, dataE4 = dataE[:3], dataE[3:5], dataE[
                    6:8], dataE[8:10]
                ynDATA = True
            if (len(dataN) >= 9):
                dataN1, dataN2, dataN3, dataN4 = dataN[:2], dataN[2:4], dataN[
                    5:7], dataN[7:9]

    gpsE = "E {}-{}-{}-{}".format(dataE1, dataE2, dataE3, dataE4)
    gpsN = "N {}-{}-{}-{}".format(dataN1, dataN2, dataN3, dataN4)
    print(gpsE, gpsN)

    return ynDATA, gpsE, gpsN
Exemplo n.º 7
0
def getGPS():
    out = ''
    ynDATA = False
    dataE1, dataE2 = 0.0, 0.0
    dataN1, dataN2 = 0.0, 0.0
    gpsE, gpsN = 0.0, 0.0
    str_gpsE, str_gpsN = "", ""

    try:
        while (serial.inWaiting()):
            out = str(serial.readline().decode('utf-8'))

    except:
        pass

    if out != '':
        gpsdata = out.split(",")
        #print(out)

        if (gpsdata[0] == "$GPRMC"):
            dataE = gpsdata[5]
            dataN = gpsdata[3]
            if (len(dataE) >= 10):
                dataE1, dataE2 = float(dataE[:3]), float(dataE[3:])
                gpsE = round(dataE1 + dataE2 / 60, 4)
                ynDATA = True
            if (len(dataN) >= 9):
                dataN1, dataN2 = float(dataN[:2]), float(dataN[2:])
                gpsN = round(dataN1 + dataN2 / 60, 4)

    str_gpsE = str(gpsE)
    str_gpsN = str(gpsN)
    #print(gpsE, gpsN)

    return ynDATA, str_gpsE, str_gpsN
Exemplo n.º 8
0
def receiveresponse():
    response = bytearray()
    bytes = bytearray(4)
    while serial.inWaiting() > 0:
        readinto(bytes)
        response.append(fromjura(bytes))
    return response
Exemplo n.º 9
0
    def openbci_id(self, serial):
        """

        When automatically detecting port, parse the serial return for the "OpenBCI" ID.

        """
        line = ''

        #
        # Wait for device to send data
        #
        # time.sleep(2)

        if serial.inWaiting():
            line = ''
            c = ''
            # Look for end sequence $$$
            while '$$$' not in line:
                c = serial.read().decode(
                    'utf-8', errors='replace'
                )  # we're supposed to get UTF8 text, but the board might behave otherwise
                line += c
            if "OpenBCI" in line:
                return True
        return False
Exemplo n.º 10
0
    def openbci_id(self, serial):
        """
        When automatically detecting port, parse the serial return for the "OpenBCI" ID.
        """
        line = ''
        # # Wait for device to send data
        # if self.openBCIFirmwareVersion == 'v1':
        #     serial.timeout = 1.0 #wait for 1 s for each character in read

        time.sleep(2)

        res = False

        if serial.inWaiting():
            line = ''
            c = ''
            # Look for end sequence $$$
            timeouted = False
            while ('$$$' not in line) and not timeouted:
                c = serial.read()
                if c == '':
                    timeouted = True
                line += c.decode('utf-8')
            if "OpenBCI" in line:
                res = True

        # if self.openBCIFirmwareVersion == 'v1':
        #     serial.timeout = self.timeout  # reset timeout to default
        return res
Exemplo n.º 11
0
    def readBytes(self,
                  count: object,
                  array: object = False,
                  write: object = False,
                  filename: object = ""):
        serial = self._serialGet(
        )  # получить данные из COMPORT в данный момент

        i = 0
        writeFile = ""

        while i < count + 18:
            if i <= 18:
                myData = serial.readline()
                i += 1
                continue
            if (serial.inWaiting() > 0):
                print(serial.readline())
                myData = serial.readline().decode("utf-8")
                if len(myData) < 5:
                    continue
                print([myData, self.getTupleValues(myData)][array])
                writeFile += myData
                i += 1
        if write:
            self.serialWrite(filename, writeFile)
Exemplo n.º 12
0
def read_data(serial):
    '''
		Function for recieve data from serial port.
		Parameters
			serial		serial.Serial instance.
		Return
			list		list of int for data recieved. Empty list if not
						recieve any thing.
	'''
    if serial is None:
        return []
    PACKAGE = []
    try:
        if not serial.is_open:
            pass
            # rospy.logwarn("Serial port is not open.")
        elif serial.is_open:
            # print serial.inWaiting()
            while serial.inWaiting():
                PACKAGE.append(ord(serial.read()))
            if len(PACKAGE) > 0:
                # rospy.logdebug("RECIEVE<< "+str(PACKAGE))
                rospy.logdebug(str(len(PACKAGE)))
    except Exception as e:
        rospy.logerr("cannot recieve data from serial port" + str(e))
    finally:
        return PACKAGE
Exemplo n.º 13
0
def cmdx(serial, command, timeout=2, retry=2):
	''' send command to zigbee router and wait for response

	serial  : serial device
	command : command line
	timeout : wait time

	return  : the response list from zigbee router
	'''
	ret = []
	ind = 0
	# if time out and can't receive data, the retry
	while ind < retry:
		ind += 1
		serial.write(command)
		n = 0
		# wait for a while and record all the response
		while n < timeout*1:
			time.sleep(0.01)
			n += 1
			count = serial.inWaiting()
			if count > 0:
				recv = ser.read(count)
				ser.flushInput()
				ret.append(recv)
		if len(ret) > 0:
			break
	return ret
Exemplo n.º 14
0
def ReadEEprom(serial, cnt=0):
    global Conf
    if cnt > 3: return None
    cnt += 1
    # TO DO: add interval for average by sensor
    serial.write(bytes("e"))  # require eeprom info
    sleep(2)
    serial.write(bytes("e"))  # Spec advises 2 X e
    nr = 0
    eeprom = {
        'sn': '0'
    }
    while serial.inWaiting():
        if nr > 25: break
        nr += 1
        try:
            line = serial.readline()
            line = str(line.strip().decode('ascii'))
            if '=' in line:
                line = line.split('=')
                eeprom[line[0].lower().strip()] = line[1].lower().strip()
            elif ', ' in line:
                line = line[0].split(',')
                if len(line) == 11:  # len(Conf['dataFlds']) measurement data
                    try:
                        eeprom['gas'] = Conf['fields'][Conf['serials'].index(
                            line[0])]
                        eeprom['sn'] = line[0]
                        eeprom['serial_number'] = line[0]
                    except:
                        pass
                    continue
        except:
            break
        sleep(0.5)
    sleep(0.5)
    while serial.inWaiting():
        serial.readline()  # empty remaining input
        sleep(0.5)
    if (not len(eeprom)) or (not 'gas' in eeprom.keys()):
        return ReadEEprom(serial, cnt=cnt)
    if Conf['debug']:
        for key in eeprom.keys():
            MyLogger.log(
                modulename, 'INFO',
                'Spec sensor eeprom %s: %s' % (key, eeprom[key].upper()))
    return eeprom
Exemplo n.º 15
0
    def soft_reset(self):
        serial = self.board.serial

        serial.write(COMMAND_CTRL_C)
        time.sleep(0.1)
        serial.write(COMMAND_CTRL_C)

        n = serial.inWaiting()
        while n > 0:
            serial.read(n)
            n = serial.inWaiting()

        time.sleep(0.1)
        serial.write(COMMAND_CTRL_D)
        data = self.board.read_until(1, b'soft reboot\r\n')
        if not data.endswith(b'soft reboot\r\n'):
            raise BoardException('could not soft_reset')
Exemplo n.º 16
0
def recv(serial):
    while True:
        count = serial.inWaiting()
        if count != 0:
            data = serial.read(count)
            serial.flushInput()
            sleep(0.1)
            return data
Exemplo n.º 17
0
def main():
    parser = argparse.ArgumentParser(description='HTTP Server')
    parser.add_argument('port',
                        type=int,
                        help='Listening port for HTTP Server')
    parser.add_argument('ip', help='HTTP Server IP')
    args = parser.parse_args()

    server = HTTPServer((args.ip, args.port), HTTPRequestHandler)
    print('HTTP Server Running...........')
    # server.serve_forever()
    threading.Thread(target=server.serve_forever).start()
    loop = asyncio.get_event_loop()
    #    sim = sim_vehicle()
    loop.run_until_complete(get_pose())
    pp = []
    for i in range(10):
        pp.append([i, i * 2])
    sim.add_path(pp)
    print(sim.get_path())
    #28H 测距定位使能:0:不测距 1 单次测量 2 持续测量 3 单 次自动输出 4 持续自动输出
    #    client = ModbusClient(method='rtu', port='COM1', timeout=1, baudrate=115200)
    #    client.connect()
    #    client.write_register(0x28, 2)

    serial = serial.Serial("COM3", 115200)
    serial.open()
    serial.write(
        [0x01, 0x10, 0x00, 0x28, 0x00, 0x01, 0x02, 0x00, 0x02, 0x21, 0xB9])
    n = serial.inWaiting()
    time.sleep(0.1)
    serial.read(n)

    while True:
        #0x2C标签X坐标,0x2D Y坐标
        #        request = client.read_input_registers(0x2C, 2)
        # request = client.read_holding_registers(0x2C, 2)
        n2 = serial.inWaiting()
        serial.write([0x01, 0x03, 0x00, 0x2A, 0x00, 0x0D, 0xA5, 0xC7])
        time.sleep(0.1)
        rec_data = serial.read(n2)
        rec_data[7:9]
        position[0] = request.registers[0]
        position[1] = request.registers[1]
        print('positon: x {}, y{}'.format(positon[0], positon[1]))
        time.sleep(0.1)
Exemplo n.º 18
0
 def write_serial(self, command, *args, **kwargs):
     hex = self.COMMANDS[command] % kwargs
     if DEBUG:
         print 'writing to serialport: %s %s' % (command, hex)
     serial.write(Utilities.hex2chr(hex))
     #time.sleep(2)
     if DEBUG:
         print 'waiting at serialport: %i' % serial.inWaiting()
Exemplo n.º 19
0
def RX_data(serial):
    try:
        if serial.inWaiting() > 0:
            result = serial.read(1)
            RX = ord(result)
            return RX
    except:
        attempts = attempts + 1
        print("Serial Not Open ", attempts)
    return 0
Exemplo n.º 20
0
 def setDH1():
     serial.write(b'\x41\x54\x44\x48\x31\x33\x41\x32\x30\x30\x0D\x0A')
     time.sleep(1)
     resp = ""
     while (serial.inWaiting() > 0):
         data = serial.read()
         resp += data
         if '\x4F\x4B\x0D' in resp:
                 print "Set DH to Router1"
                 break
Exemplo n.º 21
0
def rpi2_usart_recv(serial,lenght):
    buffers = ''
    while True:
        FIFO_len = serial.inWaiting()
        # print "Waiting data:",FIFO_len
        if lenght <= FIFO_len:
            buffers = serial.read(FIFO_len)
            # serial.flushInput()
            break
    return buffers
Exemplo n.º 22
0
 def exitCommandMode():
     serial.write(b'\x41\x54\x43\x4E\x0D\x0A')
     time.sleep(1)
     resp = ""
     while (serial.inWaiting() > 0):
         data = serial.read()
         resp += data
         if '\x4F\x4B\x0D' in resp:
                 print "Exit Command Mode"
                 break
     return 0
Exemplo n.º 23
0
 def setDL2():
     serial.write(b'\x41\x54\x44\x4C\x34\x30\x45\x38\x33\x33\x46\x31\x0D\x0A')
     time.sleep(1)
     resp = ""
     while (serial.inWaiting() > 0):
         data = serial.read()
         resp += data
         if '\x4F\x4B\x0D' in resp:
                 print "Set DL to Router2"
                 break
     return 0
Exemplo n.º 24
0
            def inner(self):
                try:
                    if not serial.isOpen():
                        if not serial.open():
                            # self.error.emit("can't not open %s,error code:%d"%(serial.portName(),serial.error()))
                            return

                    if serial.inWaiting() == 0:
                        return

                    data = bytes()
                    requestData = bytes()
                    # print('wait:',serial.in_waiting)
                    requestData = serial.read(serial.inWaiting())
                    hexData = ' '.join('{:02x}'.format(x) for x in requestData)
                    self.request.emit(hexData)
                    # else:
                    #     self.timeout.emit("Wait read ready timeout %s"%(QTime.currentTime().toString()))
                except TypeError as e:
                    print('Got Error', e)
Exemplo n.º 25
0
def lineFromSerial(serial):
    global serialBuffer
    serialBuffer = serialBuffer + serial.read(serial.inWaiting())
    if '\n' in serialBuffer:
        lines = serialBuffer.partition('\n') # returns 3-tuple with line, separator, rest
        if(lines[1] == ''):
            # separator not found, first element is incomplete line
            serialBuffer = lines[0]
            return None
        else:
            serialBuffer = lines[2]
            return lines[0]
Exemplo n.º 26
0
def readSerial(threadName, delay):
    s = ""
    while True:
        if serial.inWaiting() != 0:
            c = serial.read()
            if (c == '\n'):
                print "[%7s] %s" % (threadName, s)
                s = ""
            else:
                s += c
        else:
            time.sleep(0.01)
def readSerial(threadName, delay):
    s = ""
    while not Quit:
        if serial.inWaiting() != 0:
            c = serial.read()
            if (c == '\n'):
                print "[%7s] %s" % (threadName, s)
                s =""
            else:
                s += c
        else:
            time.sleep(0.01)
Exemplo n.º 28
0
def recv(serial):
    print('2')
    data = ''
    while serial.inWaiting() > 0:
        print(serial.inWaiting())
        print('3')
        # data += str(serial.read(15)) # ok 要配合timeout 使用, 否则要传入已知 的 size
        # data += str(serial.readline())  # ok 要配合timeout 使用
        # data += str(serial.readlines())  # ok 要配合timeout 使用
        # data += str(serial.readall())     # ok 要配合timeout 使用
        data += str(serial.read_all())  # ok 要配合timeout 使用

        print("************************************")
        #print(serial.read(13))
        print('准备打印data')
        # data = str(serial.read(19))
        print(data)
        print('data:%s' % data)
        print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")

    return data
Exemplo n.º 29
0
 def writeSetting():
     serial.write(b'\x41\x54\x57\x52\x0D\x0A')
     time.sleep(1)
     resp = ""
     while (serial.inWaiting() > 0):
         
         data = serial.read()
         resp += data
         if '\x4F\x4B\x0D' in resp:
                 print "Write Setting "
                 break
     return 0
Exemplo n.º 30
0
 def accesssCommandMode():
     print "in func"
     serial.write(b'\x2B\x2B\x2B')
     time.sleep(1)
     resp = ""
     while (serial.inWaiting() > 0):
         data = serial.read()
         resp += data
         if '\x4F\x4B\x0D' in resp:
                 print "In Command Mode"
                 break
     return 0
Exemplo n.º 31
0
def RX_data(serial):
    try:
        if serial.inWaiting() > 0:
            result = serial.read(1)
            RX = ord(result)
            return RX
        else:
            print('rx error')
            return 0
    except:
        return 0
        pass
Exemplo n.º 32
0
def recv(serial):
    data = ''
    sleep(1)
    while True:
        while serial.inWaiting() > 0:
            data += (serial.read(1)).decode()
        if data == '':
            continue
        else:
            break
    print('slave computer info: ')
    print(data)
    return data
Exemplo n.º 33
0
def ReceiveData(serial):
    tmp_wait = serial.inWaiting()
    if tmp_wait == 0:
        print('no data')
        return ''
    data = serial.read(tmp_wait)
    data_hex = data.hex()
    data_str = ''
    for i in range(len(data_hex)):
        data_str += data_hex[i]
        if i % 2 == 1:
            data_str += ' '
    return data_str.strip().upper()
Exemplo n.º 34
0
def ASK_Slave(serial, cmd_data):
    global recv_data, recv_n
    global abs_path
    timeout_count = 0
    timeout_total = 0
    print 'recv_n', recv_n
    print 'recv_data_B', recv_data
    while True:
        print "Motor is moving: ", timeout_count, " times"
        time.sleep(0.5)
        recv_n = serial.inWaiting()
        print cmd_data, '&& recv_n:', recv_n
        if recv_n >= 2:
            recv_data = serial.read(recv_n)
            print recv_n, ' && ', recv_data
            serial.flushInput()
            if 'OK' in recv_data and cmd_data[0] in recv_data:
                print 'recv_data_A', recv_data, '+', recv_n
                print 'Moving Finished.'
                recv_n = 0
                recv_data = 'N'
                serial.flushOutput()
                time.sleep(0.5)  # 1
                # Journal = open(abs_path,'a')
                # Journal.write(cmd_data[0] + "->")
                # Journal.close()
                break
            else:
                print "Wrong Control,Break!"
                recv_n = 0
                recv_data = 'N'
                serial.flushOutput()
        timeout_count += 1
        if timeout_count >= 600:
            print "No response Slave,Repeat send cmd please."
            serial.write(cmd_data)
            timeout_total += timeout_count
            timeout_count = 0
            Journal = open(abs_path, 'a')
            if timeout_total <= 600:
                Journal.write("\nSlave No response for CMD:" + cmd_data[0] +
                              " " + str(timeout_total) +
                              " times,Repeat Send CMD...\n")
            else:
                Journal.write("\nSlave No response for CMD:" + cmd_data[0] +
                              " " + str(timeout_total) +
                              " times,Shutdown System...\n")
                Journal.write("System died at: " + Get_time_str(':') + '.\n')
                os.system('sudo shudown -h now')
            Journal.close()
Exemplo n.º 35
0
def RX_data(serial):
    global Temp_count
    try:
        if serial.inWaiting() > 0:
            result = serial.read(1)
            RX = ord(result)
            return RX
        else:
            return 0
    except:
        Temp_count = Temp_count + 1
        print("Serial Not Open " + str(Temp_count))
        return 0
        pass
Exemplo n.º 36
0
def bcc_off(serial):
    global f
    serial.write(bytes.fromhex('A3 3A 00 01 01 00'))
    while True:
        flag = 0
        while serial.inWaiting() > 0:
            data = serial.readline()
            print(data, len(data))
            if data[:6] == b'\xA3\x3A\x00\x01\x00\x01':
                print("bcc off")
                flag = 1
                break
        if flag == 1:
            break
Exemplo n.º 37
0
def test(serial,expecting,timeout=30):
    tStart = time.time()
    while(1):
        if serial.inWaiting():
            time.sleep(.01)
            c = serial.read(1)
            if c == expecting[0]:
                expecting = expecting[1:]
                print repr(c),
        if expecting == "":
            return True
        if time.time()-tStart > timeout:
            return False
    return False
Exemplo n.º 38
0
def read_data(serial):
    print "read data %d" % exitflag
    #try:
    alldata = ""
    while exitflag == 0:
        #data = serial.readline()
        count = serial.inWaiting()
        if count > 0:
            data = serial.read(count)
            if data == "\n":
                alldata += data
                print alldata,
                alldata = ""
            else:
                alldata += data
Exemplo n.º 39
0
    def openbci_id(self, serial):
        line = ''
        # Espera a que el dispositivo envíe datos
        time.sleep(2)

        if serial.inWaiting():
            line = ''
            c = ''
            # Busca la secuencia de fin '$$$'
            while '$$$' not in line:
                c = serial.read().decode('utf-8')
                line += c
            if "OpenBCI" in line:
                return True
        return False
def send_command(serial, command, human, expected_response=None, crlf=True, waittime=1000):
	'''Sends a command to the device.'''

	# flush the read buffer
	serial.read(serial.inWaiting())
	
	print human
	print "<<< " + command
	serial.write(command)
	if crlf:
		serial.write("\r\n")

	time.sleep(waittime / 1000)

	if expected_response:
		n = max([serial.inWaiting(), len(expected_response)])
		#print n
		data = serial.read(n)
		#print data
		if expected_response in data:
			print ">>> OK"
		else:
			print "<<< " + command
			print ">>> ERROR: " + data
Exemplo n.º 41
0
	def recieve_message(self):
		readMsg = ''
		serial.flushInput()
		time.sleep(4)
		orig_time = time.time()
		while((time.time()-orig_time) < 5 ):
			readMsg = serial.read(serial.inWaiting())
			#print("test")
			time.sleep(1)
			if readMsg != '':
				break
			else:
				raise("problem in recieving message")
		self.logger("Recieving package %s" % readMsg)
		return readMsg
Exemplo n.º 42
0
def openbci_id(serial):
    """

    When automatically detecting port, parse the serial return for the "OpenBCI" ID.

    """
    line = ''
    #Wait for device to send data
    time.sleep(2)
    c = ''
    if serial.inWaiting():
        c = serial.read().decode('utf-8')
    if len(c) > 0:
        print(len(c))
        return True
    return False
Exemplo n.º 43
0
  def openbci_id(self, serial):
    """

    When automatically detecting port, parse the serial return for the "OpenBCI" ID.

    """
    line = ''
    #Wait for device to send data
    time.sleep(2)
    
    if serial.inWaiting():
      line = ''
      c = ''
     #Look for end sequence $$$
      while '$$$' not in line:
        c = serial.read().decode('utf-8')
        line += c
      if "OpenBCI" in line:
        return True
    return False
Exemplo n.º 44
0
  def openbci_id(self, serial):
    """

    When automatically detecting port, parse the serial return for the "OpenBCI" ID.

    """
    line = ''
    #Wait for device to send data
    time.sleep(2)

    if serial.inWaiting():
      line = ''
      c = ''
     #Look for end sequence $$$
      while '$$$' not in line:
        c = serial.read().decode('utf-8', errors='replace') # we're supposed to get UTF8 text, but the board might behave otherwise
        line += c
      if "OpenBCI" in line:
        return True
    return False
Exemplo n.º 45
0
 def reader(self, alive, q, serial, callback):
     while alive:
         try:
             data = serial.read(1)            #read one, blocking
             n = serial.inWaiting()           #look if there is more
             if n:
                 data = data + serial.read(n)    #and get as much as possible
             if data:
                 if data[3] == '\x08':
                     interrupt = self.decodefun(data)
                     callback_process = Process(target=callback, args=[interrupt[1]])
                     callback_process.start()
                     #callbackthread = threading.Thread(target=self.callback, args=[interrupt[1]])
                     #callbackthread.start()
                 else:
                     q.put(data)
                     #self.outq.put(data)
         except:
             errmsg("UPER API: serial port reading error.")
             #raise APIError("Serial port reading error.")
             alive = False
             break
Exemplo n.º 46
0
def lineFromSerial(serial):
    global serialBuffer
    inWaiting = None
    newData = None
    try:
        inWaiting = serial.inWaiting()
        if inWaiting > 0:
            newData = serial.read(inWaiting)
    except (IOError, OSError, serial.SerialException) as e:
        logMessage('Serial Error: {0})'.format(str(e)))
        return
    if newData:
        serialBuffer = serialBuffer + newData
    if '\n' in serialBuffer:
        lines = serialBuffer.partition('\n') # returns 3-tuple with line, separator, rest
        if(lines[1] == ''):
            # '\n' not found, first element is incomplete line
            serialBuffer = lines[0]
            return None
        else:
            # complete line received, [0] is complete line [1] is separator [2] is the rest
            serialBuffer = lines[2]
            return util.asciiToUnicode(lines[0])
Exemplo n.º 47
0
'''
A silly python program to test the daily-voc app.
'''

import serial
import time

serial = serial.Serial('/dev/ttyUSB0', 9600, timeout=1)
ack = '\x01\x01\x04\x0c\x44\x96\x60\x00\x41\xc7\x33\x33\x41\x8c\x00\x00\x22\x53'

while True:
    while serial.inWaiting() < 1:
        continue
    time.sleep(0.1)
    r = serial.read(8)
    serial.flushOutput()
    s = 'Rx: ' + ' '.join([hex(ord(i)) for i in r]).replace('0x', '')
    print s

    time.sleep(0.2)
    s = 'Tx: ' + ' '.join([hex(ord(i)) for i in ack]).replace('0x', '')
    print s
    serial.write(ack)
Exemplo n.º 48
0
def serRead(threadName, delay):
    if serial.inWaiting() > 0:
        msg = serial.readline()
        print ("[Arduino | %s] serRead > %s" %(time.ctime(time.time()), msg))
        parse_msg(msg)
    real_delay_call(serRead, delay, threadName, delay)
Exemplo n.º 49
0
	def check_package(self, package, status=None, count = None):
		#read_message = ''
		#test
		time.sleep(4)
		read_message = serial.read(serial.inWaiting())
		if read_message == '':
			orig_time = time.time()
			while((time.time()-orig_time)<6):
				if read_message == '':
					print("read again")
					time.sleep(2)
					read_message = serial.read(serial.inWaiting())
				else:
					break
			if read_message == '':
				while (count != None) and (count < 3):
					count = count + 1
					print("resend")
					#rebreak the package
					resend = self.decode_package(package)
					#transmit and repackage
					repackage = self.transmit_package(resend['reciever'], resend['data_type'], resend['payload'])
					try:
						self.check_package(package, None, count)
					except:
						pass
				else:
					raise Exception("boo")
		#orig_time = time.time()
		#while((read_message == '') & ((orig_time-time.time())<5)):
		#	read_message = self.recieve_message()
		#if read_message == '':
		#	raise "Problem in sending"
		confirm_package = self.decode_package(read_message)
		original_package = self.decode_package(package)
		if confirm_package['sender'] != original_package['reciever']:
			print("Error in Sender INIT Path")
		else:
			print("Sender Match")
		if original_package['data_type'] == '0000':
			if confirm_package['data_type'] != '0001':
				print("Error in Data Type INIT Path")
			elif confirm_package['payload'] != original_package['payload']:
				print("Error in Payload INIT Path")
			else:
				print("Go INIT Path")
				package = self.transmit_package(original_package['reciever'], '0010', '')
				#try:
				self.check_package(package)
				#except:
				#	pass
		elif original_package['data_type'] == '0010':
			if confirm_package['data_type'] != '0011':
				print("Error in Data Type Confirm Path")
			else:
				print ("Go Confirm Path")
		elif original_package['data_type'] == '0100':
			if confirm_package['data_type'] != '0101':
				print("Error in Data Type Status")
			else:
				if confirm_package['payload'] == '0'.zfill(24):
					print("Changing Run Status")
					status(False)
Exemplo n.º 50
0
def picture640x480():
    serial = serial.Serial("/dev/ttyO1", baudrate=38400)

    # Initialize camera 
    """     (SYSTEM_RESET command)
    """
    serial.write(b'\x56\x00\x26\x00')
    resp = ""
    time.sleep(1)
    while(serial.inWaiting() > 0):
            data = serial.read()
            resp += data
            if "Init end\r\n" in resp:
                    print "Ready"
                    break
    
    # Set image size to 640 x 480 
    """     according to the command manual 0x54 corresponds with DOWNSIZE_STATUS
            Everything looks like it might refer to DOWNSIZE_SIZE, 0x53. The return code fits
            exactly with it. PROBABLY MISTAKEN
    
            TODO inspect this more carefully.
    """     
    serial.write(b'\x56\x00\x54\x01\x00')
    resp = ""
    time.sleep(1)
    while (serial.inWaiting() > 0):
            data = serial.read()
            resp += data
            if b'\x76\x00\x54\x00\x00' in resp:
                    print "Size set"
                    break
    
    # Take picture
    """     FBUF_CTRL: control frame buffer register
            particularly this instruction stop the current frame.
                    0x56+serial number+0x36+0x01+control flag(1 byte)
    """
    serial.write(b'\x56\x00\x36\x01\x00')
    resp = ""
    time.sleep(2)
    while(serial.inWaiting() > 0):
            data = serial.read()
            resp += data
            if b'\x76\x00\x36\x00\x00' in resp:
                    print "Picture taken"
                    break
            elif b'\x76\x00\x36\x03\x00' in resp:
                    # Error
                    raise Exception("Error at FBUF_CTRL")
    
    
    #Get JPG size
    """     GET_FBUF_LEN: get byte-lengths inFBUF
                    0x56+serial number+0x34+0x01+FBUF type(1 byte)
    """
    serial.write(b'\x56\x00\x34\x01\x00')
    resp = ""
    time.sleep(1)
    while(serial.inWaiting() > 0):
            data = serial.read()
            resp += data
            if b'\x76\x00\x34\x00\x04\x00\x00' in resp:
                    msb = serial.read()
                    lsb = serial.read()
                    print "Image file size: %d bytes" % (ord(msb) << 8 | ord(lsb))
    
    # Write image to file
    """     READ_FBUF: read image data from FBUF
                    0x56+serial number+0x32+0x0C+FBUF type(1 byte)+control mode(1 byte) +starting address(4 bytes)+data-length(4 bytes)+delay(2 bytes)
    """
    serial.write(b'\x56\x00\x32\x0C\x00\x0A\x00\x00\x00\x00\x00\x00%c%c\x00\x0A'
    % (msb,lsb))
    time.sleep(5)
    now = datetime.datetime.now()
    filename = "%d.%02d.%02d.%02d.%02d.%02d.jpg" % \
    (now.year,now.month,now.day,now.hour,now.minute,now.second)
    resp = serial.read(size=5)
    if b'\x76\x00\x32\x00\x00' in resp:
            with open("/tmp/" + filename, 'wb') as f:
                    while(serial.inWaiting() > 0):
                            data = serial.read()
                            f.write('%c' % data)
            print "Image written to /tmp/%s" % (filename)
    
    
    # send the image through ssh
    comando = "scp /tmp/%s [email protected]:~/Desktop" % (filename)
    os.system(comando)
Exemplo n.º 51
0
         if '\x4F\x4B\x0D' in resp:
                 print "Exit Command Mode"
                 break
     return 0
 
     
 
    
    
 # Initialize camera
 
 serial = serial.Serial("/dev/ttyUSB0", baudrate=38400,timeout=0.2)
 serial.write(b'\x56\x00\x26\x00')
 resp = ""
 time.sleep(1)
 while (serial.inWaiting() > 0):
         data = serial.read()
         resp += data
         if '\x76\x00\x26\x00' in resp:
                 print "Ready"
                 break
 
 
 
 
 # Set image size to 640 x 480
 #serial.write(b'\x56\x00\x54\x01\x00')
 # Set image size to 640 x 480
 #serial.write(b'\x56\x00\x54\x01\x00')
 serial.flushInput()
 serial.flushOutput()
Exemplo n.º 52
0
try:
    print >>sys.stderr, 'waiting to receive message'
    data, address = sock.recvfrom(4096)
    print data
    if data == 'start':
        # Connect with serial port
        try:
            serial = serial.Serial('/dev/ttyAMA0', baudrate=9600, timeout=3)    
        except:
            print 'error opening serial port'                
        resp = ''
        fileName = ''
        date = ''
        try:
            while True:
                while (serial.inWaiting() > 0):
                    resp += serial.read()            
                    if '\r\n' in resp:
                        if '$GPRMC' in resp:
                            data = resp.split(',')
                            # Status, V=Navigation receiver warning A=Valid
                            if data[2] == 'A':
                                # Get time
                                hour = data[1][0:2]
                                min = data[1][2:4]
                                sec = data[1][4:6]
                                mil = data[1][7:10]
                                time = '%s%s%s%s' % (hour, min, sec, mil)
                                # Get date
                                day = data[9][0:2]
                                month = data[9][2:4]
Exemplo n.º 53
0
    "id": 0
}
send = {
    "data": "",
    "key" : key
}
print "Reading file..."
f = open("helpers.txt", "r+")
for line in f:
    line = line.replace("\n", "")
    data = line.split(", ")
    helpers.append([data[0], data[1]])
f.close()
print "Done. Ready to scan."
while True:
    if serial.inWaiting() > 0:
        read_result = serial.read(12)
        rfid = format(read_result.decode(encoding="utf-8"))
        if len(rfid) == 12:
            rfid = rfid[1:11]
            print("Read card " + rfid)
            for student in helpers:
                if(rfid == student[0]):
                    print "You are " + student[1]
                    send_data["id"] = student[1]
                    send["data"] = json.dumps(send_data)
                    print requests.post(url, data=send).text
        else:
            print("Misread card")
        print("Please wait for 1 second...");
        time.sleep(1)
Exemplo n.º 54
0
Arquivo: gb580.py Projeto: odkq/gb580
def writeserial(command, *args, **kwargs):
    hex = COMMANDS[command] % kwargs
    print 'writing to serialport ' + hex
    serial.write(hex2chr(hex))
    # time.sleep(2)
    print 'waiting at serialport: %i' % serial.inWaiting()
Exemplo n.º 55
0
import serial
import sys

# Connect with serial port
try:
    serial = serial.Serial("/dev/ttyAMA0", baudrate=9600, timeout=3)
except:
    print "error opening serial port"

resp = ""

try:
    while True:
        while serial.inWaiting() > 0:
            resp += serial.read()
            if "\r\n" in resp:
                if "$GPRMC" in resp:
                    data = resp.split(",")
                    # Status, V=Navigation receiver warning A=Valid
                    if data[2] == "A":
                        # Get time
                        hour = data[1][0:2]
                        min = data[1][2:4]
                        sec = data[1][4:6]
                        mil = data[1][7:10]
                        string = "%s:%s:%s.%s" % (hour, min, sec, mil)
                    else:
                        string = "no signal"
                    print string
                resp = ""
except:
Exemplo n.º 56
0
def arduinoRead(serial):

    while True:
        time.sleep(2)

        t, v = [], []
        data = serial.read(serial.inWaiting())
        sample = data.split('\n')
        del sample[-1]

        for line in sample:
        	values = line.split()
        	values = map(int, values)

        	# print "SIZE: ", len(values)

        	# print "t val 0: ", values[0]
        	# print "v val 1: ", values[1]        	

        	# append if there are both values, otherwise it breaks
        	if len(values) == 2:
	        	t.append(values[0])
	        	v.append(values[1])

        	# if values[0] and values[1]:
        	# 	t.append(values[0])
        	# 	v.append(values[1])

        vSmooth = gaussSmooth(v);

        # print v
        # print vSmooth

        # print "v size and type: ", len(v), type(v)
        # print "vSmooth size and type: ", len(vSmooth), type(vSmooth)

        # vNp = np.array(v)

        # maximaV = argrelextrema(vNp, np.greater)
        # print maximaV

        # customMaximaV = maxima(v)
        # print customMaximaV

        smoothMaxima = maxima(vSmooth)
        # print smoothMaxima

        bpm, ibi = sampleStats(smoothMaxima, t)

        vStd = np.std(v)
        print "standard deviation: ", vStd
        status = 0 #0: not a good pulse. 1: good pulse.
        stdThresholdLow = 25;
        stdThresholdHigh = 400;

        if vStd > stdThresholdLow and vStd < stdThresholdHigh and bpm > 20 and ibi < 3000:
        	status = 1

        print "SAMPLE BPM: ", bpm
        print "PULSE STATUS: ", status

        epochTime = time.time()

        fullStats[0].append(t[-1])
        fullStats[1].append(epochTime)
        fullStats[2].append(bpm)
        fullStats[3].append(ibi)
        fullStats[4].append(status)

        # print fullStats

        writeFile.write(str(t[-1]) + "\t" + str(epochTime) + "\t" + str(bpm) + "\t" + str(ibi) + "\t" + str(status) + "\n");
Exemplo n.º 57
0
def rfidFlush(serial):
	serial.read(serial.inWaiting())
	serial.flushInput()