예제 #1
0
    def send(self, messageID, rawStringFromMessageToSend, senderStamp=0):
        now = time.time()

        sentTimeStamp = cluonDataStructures_pb2.cluon_data_TimeStamp()
        sentTimeStamp.seconds = int(now)
        sentTimeStamp.microseconds = int((now - int(now)) * 1000 * 1000)

        envelope = cluonDataStructures_pb2.cluon_data_Envelope()
        envelope.dataType = messageID
        envelope.sent.seconds = sentTimeStamp.seconds
        envelope.sent.microseconds = sentTimeStamp.microseconds
        envelope.sampleTimeStamp.seconds = sentTimeStamp.seconds
        envelope.sampleTimeStamp.microseconds = sentTimeStamp.microseconds
        envelope.senderStamp = senderStamp
        envelope.serializedData = rawStringFromMessageToSend

        serializedEnvelope = envelope.SerializeToString()
        size = len(serializedEnvelope)

        # Add Envelope header.
        a = struct.pack("<B", *bytearray([
            0x0D,
        ]))
        b = struct.pack("<L", ((size & 0xFFFFFF) << 8) | 0xA4)

        data = a + b + serializedEnvelope
        self.sock.sendto(data, (self.MULTICAST_GROUP, self.MULTICAST_PORT))
예제 #2
0
    def __runner(self):
        LENGTH_ENVELOPE_HEADER = 5
        buf = ""
        expectedBytes = 0
        consumedEnvelopeHeader = False

        while True:
            if consumedEnvelopeHeader:
                if len(buf) >= expectedBytes:
                    envelope = cluonDataStructures_pb2.cluon_data_Envelope()
                    envelope.ParseFromString(buf)
                    self.__process(envelope)
                    # Start over and read next container.
                    consumedEnvelopeHeader = False
                    buf = buf[expectedBytes:]
                    expectedBytes = 0

            if not consumedEnvelopeHeader:
                if len(buf) >= LENGTH_ENVELOPE_HEADER:
                    consumedEnvelopeHeader = True
                    byte0 = buf[0]
                    byte1 = buf[1]

                    # Check for Envelope header.
                    if ord(byte0) == int('0x0D', 16) and ord(byte1) == int(
                            '0xA4', 16):
                        v = struct.unpack(
                            '<L', buf[1:5]
                        )  # Read uint32_t and convert to little endian.
                        expectedBytes = v[
                            0] >> 8  # The second byte belongs to the header of an Envelope.
                        buf = buf[5:]  # Remove header.
                    else:
                        print "Failed to consume header from Envelope."

            # Receive data from UDP socket.
            data = self.sock.recv(2048)
            if len(data) != 2048:
                # Avoid corrupt packets.
                buf = buf + data
# Read Envelopes from .rec file.
with open(sys.argv[1], "rb") as f:
    buf = b""
    bytesRead = 0
    expectedBytes = 0
    LENGTH_ENVELOPE_HEADER = 5
    consumedEnvelopeHeader = False

    byte = f.read(1)
    while byte != "":
        buf = b"".join([buf, byte])
        bytesRead = bytesRead + 1

        if consumedEnvelopeHeader:
            if len(buf) >= expectedBytes:
                envelope = cluonDataStructures_pb2.cluon_data_Envelope()
                envelope.ParseFromString(buf)
                printEnvelope(envelope)
                # Start over and read next container.
                consumedEnvelopeHeader = False
                buf = buf[expectedBytes:]
                expectedBytes = 0

        if not consumedEnvelopeHeader:
            if len(buf) >= LENGTH_ENVELOPE_HEADER:
                consumedEnvelopeHeader = True
                byte0 = buf[0]
                byte1 = buf[1]

                # Check for Envelope header.
                if byte0 == 0x0D and byte1 == 0xA4:
def filterFile(filename_in, filename_out, start_time_relative, time_window):
    assert filename_in != filename_out, 'Input and output rec files are the same!'
    first_envelope = True

    with open(filename_in, "rb") as f_in:
        with open(filename_out, 'wb') as f_out:
            buf = b""
            bytesRead = 0
            expectedBytes = 0
            LENGTH_ENVELOPE_HEADER = 5
            consumedEnvelopeHeader = False

            byte = f_in.read(1)
            while byte != "":
                buf = b"".join([buf, byte])
                bytesRead = bytesRead + 1

                if consumedEnvelopeHeader:
                    if len(buf) >= expectedBytes:
                        envelope = cluonDataStructures_pb2.cluon_data_Envelope(
                        )
                        envelope.ParseFromString(buf)

                        # Convert timestamp from 2 ints to a float
                        timestamp = envelope.sampleTimeStamp.seconds + 1e-6 * envelope.sampleTimeStamp.microseconds

                        # Extract timestamp from first envelope
                        if first_envelope:
                            first_envelope = False
                            start_time = timestamp
                            stop_time = start_time + float(time_window)

                        # Check whether current timestamp is within limits
                        if timestamp >= start_time + start_time_relative and timestamp <= stop_time:
                            writeMessageToFile(f_out, header, buf)
                        elif timestamp > stop_time:
                            break

                        # Start over and read next container.
                        consumedEnvelopeHeader = False
                        buf = buf[expectedBytes:]
                        expectedBytes = 0

                if not consumedEnvelopeHeader:
                    if len(buf) >= LENGTH_ENVELOPE_HEADER:
                        consumedEnvelopeHeader = True
                        byte0 = buf[0]
                        byte1 = buf[1]

                        # Check for Envelope header.
                        if byte0 == 0x0D and byte1 == 0xA4:
                            v = struct.unpack(
                                '<L', buf[1:5]
                            )  # Read uint32_t and convert to little endian.
                            expectedBytes = v[
                                0] >> 8  # The second byte belongs to the header of an Envelope.
                            header = buf
                            buf = buf[expectedBytes:]  # Remove header.
                        else:
                            print("Failed to consume header from Envelope.")

                # Read next byte.
                byte = f_in.read(1)

                # End processing at file's end.
                if not byte:
                    break