Ejemplo n.º 1
0
 def readDLMSPacket2(self, data, reply):
     if not data:
         return
     notify = GXReplyData()
     reply.error = 0
     eop = 0x7E
     #In network connection terminator is not used.
     if self.client.interfaceType == InterfaceType.WRAPPER and isinstance(
             self.media, GXNet):
         eop = None
     p = ReceiveParameters()
     p.eop = eop
     p.waitTime = self.waitTime
     if eop is None:
         p.Count = 8
     else:
         p.Count = 5
     self.media.eop = eop
     rd = GXByteBuffer()
     with self.media.getSynchronous():
         if not reply.isStreaming():
             self.writeTrace(
                 "TX: " + self.now() + "\t" + GXByteBuffer.hex(data),
                 TraceLevel.VERBOSE)
             print("TX: " + self.now() + "\t" + GXByteBuffer.hex(data))
             self.media.send(data)
         pos = 0
         try:
             while not self.client.getData(rd, reply, notify):
                 if notify.data.size != 0:
                     if not notify.isMoreData():
                         t = GXDLMSTranslator()
                         xml = t.dataToXml(notify.data)
                         print(xml)
                         notify.clear()
                     continue
                 elif not p.eop:
                     p.count = self.client.getFrameSize(rd)
                 while not self.media.receive(p):
                     pos += 1
                     if pos == 3:
                         raise TimeoutException(
                             "Failed to receive reply from the device in given time."
                         )
                     if rd.size == 0:
                         print("Data send failed.  Try to resend " +
                               str(pos) + "/3")
                         self.media.send(data, None)
                 rd.set(p.reply)
                 p.reply = None
         except Exception as e:
             self.writeTrace("RX: " + self.now() + "\t" + str(rd),
                             TraceLevel.ERROR)
             print("RX: " + self.now() + "\t" + str(rd))
             raise e
         self.writeTrace("RX: " + self.now() + "\t" + str(rd),
                         TraceLevel.VERBOSE)
         print("RX: " + self.now() + "\t" + str(rd))
         if reply.error != 0:
             raise GXDLMSException(reply.error)
Ejemplo n.º 2
0
 def __init__(self):
     #List available serial ports.
     print("Available ports:")
     print(str(GXSerial.getPortNames()))
     #Define End Of Packet char.
     eop = '\r'
     #Make connection using serial port.
     media = GXSerial("COM10")
     print(str(media))
     #Start to listen events from the media.
     media.addListener(self)
     #Update port here to call onPropertyChanged event.
     #TODO: Update correct port.
     media.port = "UPDATE CORRECT PORT"
     #Show all traces.
     media.trace = TraceLevel.VERBOSE
     #Set EOP for the media.
     media.eop = eop
     try:
         #Open the connection.
         media.open()
         r = ReceiveParameters()
         r.eop = eop
         r.count = 5
         #Wait reply for 2 seconds.
         r.waitTime = 2000
         ############################
         #Send data synchronously.
         with media.getSynchronous():
             media.send("Hello world!")
             #Send EOP
             media.send('\r')
             ret = media.receive(r)
             if ret:
                 print(str(r.reply.decode("ascii")))
             else:
                 raise Exception("Failed to receive reply from the server.")
         ############################
         #Send async data.
         media.send("Server !\r")
         #Wait 1 second to receive reply from the server.
         time.sleep(1)
     except (KeyboardInterrupt, SystemExit, Exception) as ex:
         print(ex)
     media.close()
     media.removeListener(self)
Ejemplo n.º 3
0
 def __init__(self):
     #Define End Of Packet char.
     eop = 0x7e
     #Make connection using TCP/IP to localhost.
     #Use ::1 if you want to use IP v6 address.
     media = GXNet(NetworkType.TCP, "localhost", 0)
     #Start to listen events from the media.
     media.addListener(self)
     print(str(media))
     #Update port here to call onPropertyChanged event.
     media.port = 1000
     #Show all traces.
     media.trace = TraceLevel.VERBOSE
     #Set EOP for the media.
     media.eop = eop
     try:
         #Open the connection.
         media.open()
         r = ReceiveParameters()
         r.eop = eop
         r.count = 5
         #Wait reply for 2 seconds.
         r.waitTime = 2000
         ############################
         #Send data synchronously.
         with media.getSynchronous():
             media.send("Hello world!")
             #Send EOP
             media.send(eop)
             ret = media.receive(r)
             if ret:
                 print(str(r.reply.decode("ascii")))
             else:
                 raise Exception("Failed to receive reply from the server.")
         ############################
         #Send async data.
         media.send("Server !")
         media.send(eop)
         #Wait 1 second to receive reply from the server.
         time.sleep(1)
     except (KeyboardInterrupt, SystemExit, Exception) as ex:
         print(ex)
     media.close()
     media.removeListener(self)
Ejemplo n.º 4
0
    def initializeOpticalHead(self):
        if self.useOpticalHead and isinstance(self.media, GXSerial):
            p = ReceiveParameters()
            p.allData = False
            p.eop = '\n'
            p.waitTime = self.waitTime
            with self.media.getSynchronous():
                data = "/?!\r\n"
                self.writeTrace("TX: " + self.now() + "\t" + data,
                                TraceLevel.VERBOSE)
                self.media.send(data)
                if not self.media.receive(p):
                    raise Exception("Failed to received reply from the media.")

                self.writeTrace("RX: " + self.now() + "\t" + str(p.reply),
                                TraceLevel.VERBOSE)
                #If echo is used.
                replyStr = str(p.reply)
                if data == replyStr:
                    p.reply = None
                    if not self.media.receive(p):
                        raise Exception(
                            "Failed to received reply from the media.")
                    self.writeTrace("RX: " + self.now() + "\t" + str(p.reply),
                                    TraceLevel.VERBOSE)
                    replyStr = str(p.reply)

            if not replyStr or replyStr[0] != '/':
                raise Exception("Invalid responce : " + replyStr)
            baudrate = replyStr[4]
            if baudrate == '0':
                bitrate = 300
            elif baudrate == '1':
                bitrate = 600
            elif baudrate == '2':
                bitrate = 1200
            elif baudrate == '3':
                bitrate = 2400
            elif baudrate == '4':
                bitrate = 4800
            elif baudrate == '5':
                bitrate = 9600
            elif baudrate == '6':
                bitrate = 19200
            else:
                raise Exception("Unknown baud rate.")

            print("Bitrate is : " + bitrate)
            #Send ACK
            #Send Protocol control character
            controlCharacter = '2'.encode()
            #"2" HDLC protocol procedure (Mode E)
            #Mode control character
            #"2" //(HDLC protocol procedure) (Binary mode)
            modeControlCharacter = '2'.encode()
            #Set mode E.
            tmp = bytearray([
                0x06, controlCharacter, baudrate, modeControlCharacter, 13, 10
            ])
            p.reply = None
            with self.media.getSynchronous():
                self.media.send(tmp)
                self.writeTrace(
                    "TX: " + self.now() + "\t" + GXCommon.toHex(tmp),
                    TraceLevel.VERBOSE)
                p.waitTime = 200
                if self.media.receive(p):
                    self.writeTrace("RX: " + self.now() + "\t" + str(p.reply),
                                    TraceLevel.VERBOSE)
                self.media.close()
                self.media.dataBits = 8
                self.media.parity = Parity.NONE
                self.media.stopBits = StopBits.ONE
                self.media.baudRate = bitrate
                self.media.open()
                #This sleep make sure that all meters can be read.
                time.sleep(1000)
Ejemplo n.º 5
0
    def initializeConnection(self):
        self.media.open()
        if self.iec and isinstance(self.media, GXSerial):
            p = ReceiveParameters()
            p.allData = False
            p.eop = '\n'
            p.waitTime = self.waitTime
            with self.media.getSynchronous():
                data = "/?!\r\n"
                self.writeTrace("TX: " + self.now() + "\t" + data,
                                TraceLevel.VERBOSE)
                self.media.send(data)
                if not self.media.receive(p):
                    raise Exception("Failed to received reply from the media.")

                self.writeTrace("RX: " + self.now() + "\t" + str(p.reply),
                                TraceLevel.VERBOSE)
                #If echo is used.
                replyStr = str(p.reply)
                if data == replyStr:
                    p.reply = None
                    if not self.media.receive(p):
                        raise Exception(
                            "Failed to received reply from the media.")
                    self.writeTrace("RX: " + self.now() + "\t" + str(p.reply),
                                    TraceLevel.VERBOSE)
                    replyStr = str(p.reply)

            if not replyStr or replyStr[0] != '/':
                raise Exception("Invalid responce : " + replyStr)
            baudrate = replyStr[4]
            if baudrate == '0':
                bitrate = 300
            elif baudrate == '1':
                bitrate = 600
            elif baudrate == '2':
                bitrate = 1200
            elif baudrate == '3':
                bitrate = 2400
            elif baudrate == '4':
                bitrate = 4800
            elif baudrate == '5':
                bitrate = 9600
            elif baudrate == '6':
                bitrate = 230400
            else:
                raise Exception("Unknown baud rate.")

            print("Bitrate is : " + bitrate)
            #Send ACK
            #Send Protocol control character
            controlCharacter = '2'.encode()
            #"2" HDLC protocol procedure (Mode E)
            #Mode control character
            #"2" //(HDLC protocol procedure) (Binary mode)
            modeControlCharacter = '2'.encode()
            #Set mode E.
            tmp = bytearray([
                0x06, controlCharacter, baudrate, modeControlCharacter, 13, 10
            ])
            p.reply = None
            with self.media.getSynchronous():
                self.media.send(tmp)
                self.writeTrace(
                    "TX: " + self.now() + "\t" + GXCommon.toHex(tmp),
                    TraceLevel.VERBOSE)
                p.waitTime = 200
                if self.media.receive(p):
                    self.writeTrace("RX: " + self.now() + "\t" + str(p.reply),
                                    TraceLevel.VERBOSE)
                self.media.close()
                self.media.dataBits = 8
                self.media.parity = Parity.NONE
                self.media.stopBits = StopBits.ONE
                self.media.baudRate = bitrate
                self.media.open()
                #This sleep make sure that all meters can be read.
                time.sleep(1000)

        reply = GXReplyData()
        data = self.client.snrmRequest()
        if data:
            self.readDLMSPacket(data, reply)
            self.client.parseUAResponse(reply.data)
            size = self.client.limits.maxInfoTX + 40
            self.replyBuff = bytearray(size)
        reply.clear()
        self.readDataBlock(self.client.aarqRequest(), reply)
        self.client.parseAareResponse(reply.data)
        reply.clear()
        if self.client.authentication > Authentication.LOW:
            for it in self.client.getApplicationAssociationRequest():
                self.readDLMSPacket(it, reply)
            self.client.parseApplicationAssociationResponse(reply.data)