Python脚本在Ubuntu服务器中崩溃，但在raspbian下工作

我对这里的Python脚本有问题。 我的问题是，它在Raspberry 3上工作，但在Ubuntu服务器下崩溃。 该脚本通过vpn连接到Teltonika RUT955 LTE路由器并收集GPS数据。它毫无问题地工作。现在我将脚本从树莓复制到我的Ubuntu服务器（不是VM），脚本崩溃。 当我在我的笔记本电脑（LinuxMint）上尝试这个脚本时，它可以工作。我有另一个Ubuntu服务器，但同样，它崩溃了

我的Raspi上的Python版本是2.7.9，Ubuntu服务器上的Python版本是2.7.12

脚本在函数解包时崩溃。

这是我的密码：

 #!/usr/bin/env python

import socket
import threading
from time import gmtime, strftime
import ConfigParser
from optparse import OptionParser
import struct
import binascii
from datetime import datetime
import dbgps
import time


TCP_IP = '10.81.0.1'
TCP_PORT = 17050


def unpack(fmt, data):
    try:
        return struct.unpack(fmt, data)
    except struct.error:
        flen = struct.calcsize(fmt.replace('*', ''))
        alen = len(data)
        idx = fmt.find('*')
        before_char = fmt[idx-1]
        n = (alen-flen)/struct.calcsize(before_char)+1
        fmt = ''.join((fmt[:idx-1], str(n), before_char, fmt[idx+1:]))
        return struct.unpack(fmt, data)

class GPSTerminal:
    def __init__(self, socket):
        self.socket = socket[0]
        self.ip = socket[1][0]
        self.socket.settimeout(15)
        self.initVariables()

    def initVariables(self):
        self.imei = "unknown"
        self.sensorsDataBlocks = []
        self.error = []
        self.blockCount = 0
        self.raw = ''

        self.success = True
        self.dataBreak = 0
        self.possibleBreakCount = 5


    def startReadData(self):
        try:
            self.proceedConnection()
        except socket.timeout, e:
            self.success = False

    def proceedConnection(self):
        if self.isCorrectConnection():
            self.readIMEI()
            if self.imei:
                self.proceedData()
        else:
            self.error.append( "Incorrect connection data stream" )
            self.success = False

    def proceedData(self):
        self.time = datetime.now()
        self.data = self.readData()
        if self.data:
            Zeros, AVLLength, CodecID, BlockCount, Hexline = unpack("HLBBs*", self.data)
            print "test"

            self.Hexline = binascii.hexlify(Hexline)
            self.blockCount = BlockCount
            self.AVL = 0 # AVL ? Looks like data reading cursor
            proceed = 0
            AVLBlockPos = 0

            while proceed < BlockCount:
                try:
                    data = self.proceedBlockData()
                    if len(data) > 1: # Daten empfangen und in die DB schreiben
                        #dbgps.DBsendAlchemy("Update container_gps Set lon ='"+str(data['Lon'])+"', lat ='"+str(data['Lat'])+"', richtung='"+str(data['GpsCourse'])+"', Timestamp ='"+str(int(data['Timestamp']))+"' where IMEI='"+str(data['IMEI'])+"'")
                        #time.sleep(0.2)
                        print str(data['Lon'])
                    self.sensorsDataBlocks.append( data )
                except ValueError, e:
                    self.dataBreak += 1
                    self.reReadData(Hexline)
                    if self.dataBreak > self.possibleBreakCount :
                        self.error.append( "Data break" )
                        self.success = False
                        return
                    else:
                        self.AVL = AVLBlockPos
                        proceed -= 1
                proceed += 1
                AVLBlockPos = self.AVL
        else:
            self.error.append( "No data received" )
            self.success = False

    def readData(self, length = 8192):
        data = self.socket.recv(length)
        self.raw += data
        return data

    def reReadData(self, Hexline):
        HexlineNew = unpack("s*", self.readData())
        Hexline += HexlineNew[0]
        self.Hexline = binascii.hexlify(Hexline)

    def proceedBlockData(self):
        DateV = '0x'+ self.extract(16)
        DateS = round(long( DateV, 16) /1000, 0)
        Prio = self.extract_int(2)
        GpsLon = self.extract_int(8)
        GpsLat = self.extract_int(8)
        Lon = str(float(GpsLon)/10000000)
        Lat = str(float(GpsLat)/10000000)
        GpsH = self.extract_int(4)
        GpsCourse = self.extract_int(4)
        GpsSat = self.extract_int(2)
        GpsSpeed = self.extract_int(4)

        IOEventCode = self.extract_int(2)
        NumOfIO = self.extract_int(2)

        sensorDataResult = {}
        pais_count = 0
        for i in [1,2,4,8]:
            pc = 0
            data = self.readSensorDataBytes(i)
            for iocode in data.keys():
                pais_count+=1
                sensorDataResult[iocode] = data[iocode]
                pc += 1

        #return {'imei' : self.imei, 'date': DateS, 'Lon': Lon, 'Lat': Lat, 'GpsSpeed': GpsSpeed, 'GpsCourse': GpsCourse, 'sensorData': sensorDataResult}
        return {'IMEI' : self.imei, 'Timestamp': DateS, 'Lon': Lon, 'Lat': Lat, 'GpsSpeed': GpsSpeed, 'GpsCourse': GpsCourse}       

    def readSensorDataBytes(self, count):
        result = {}
        pairsCount = self.extract_int(2)
        i = 1
        while i <= pairsCount:
            IOCode = self.extract_int(2)
            IOVal = self.extract_int( count * 2)
            result[IOCode] = IOVal
            i+=1
        return result

    def extract(self, length):
        result = self.Hexline[ self.AVL : (self.AVL + length) ]
        self.AVL += length
        return result

    def extract_int(self, length):
        return int(self.extract(length), 16)

    def readIMEI(self):
        IMEI = self.readData(34)
        self.imei = IMEI
        self.socket.send(chr(01))

    def isCorrectConnection(self):

        hello = self.readData(2)
        return '(15,)' == str(struct.unpack("!H", hello ))

    def sendOKClient(self):
        self.socket.send(struct.pack("!L", self.blockCount))
        self.closeConnection()

    def sendFalse(self):
        self.socket.send(struct.pack("!L", 0))
        self.closeConnection()

    def closeConnection(self):
        self.socket.close()

    def getSensorData(self):
        return self.sensorsDataBlocks
    def getIp(self):
        return self.ip
    def getImei(self):
        return self.imei
    def isSuccess(self):
        return self.success

class ClientThread(threading.Thread):
    def __init__(self, group=None, target=None, name=None, *args, **kwargs):
        threading.Thread.__init__(self)
        self.socket = kwargs['socket']


    def run(self):
        client = self.socket
        if client:
            print "a"
            terminalClient = GPSTerminal(self.socket)
            print "b"
            terminalClient.startReadData()
            print "c"
            if terminalClient.isSuccess():
                terminalClient.sendOKClient()
            else:
                terminalClient.sendFalse()
                pass
            terminalClient.closeConnection()

if __name__ == "__main__":

    optParser = OptionParser()

    (options, args) = optParser.parse_args()
    config = ConfigParser.RawConfigParser()

    print "Server gestartet"

    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

    server.bind((TCP_IP, TCP_PORT))
    server.listen(5)

    while True:
        ClientThread(socket=server.accept(), config = config).start()

#/usr/bin/env python
导入套接字
导入线程
从时间导入gmtime，strftime
导入配置分析器
从optpasse导入OptionParser
导入结构
导入binascii
从日期时间导入日期时间
导入dbgps
导入时间
TCP_IP='10.81.0.1'
TCP_端口=17050
def拆包（fmt，数据）：
尝试：
返回结构解包（fmt，数据）
除了struct.error：
flen=struct.calcsize（fmt.replace（'*'，''）
alen=len（数据）
idx=fmt.find（'*'））
前字符=fmt[idx-1]
n=（alen-flen）/struct.calcsize（在字符之前）+1
fmt=''.join（（fmt[：idx-1]，str（n），在_char之前，fmt[idx+1:]））
返回结构解包（fmt，数据）
类别GPSTerminal：
def uuu init uuuu（自我，套接字）：
self.socket=套接字[0]
self.ip=socket[1][0]
self.socket.settimeout（15）
self.initVariables（）
def初始变量（自身）：
self.imei=“未知”
self.sensorsDataLocks=[]
self.error=[]
self.blockCount=0
self.raw=“”
自我成功=真实
self.dataBreak=0
self.possibleBreakCount=5
def startReadData（自）：
尝试：
self.proceedConnection（）
除socket.timeout外，e:
自我成功=错误
def proceedConnection（自）：
如果self.isCorrectConnection（）：
self.readIMEI（）
如果self.imei：
self.proceedData（）
其他：
self.error.append（“不正确的连接数据流”）
自我成功=错误
def proceedData（自身）：
self.time=datetime.now（）
self.data=self.readData（）
如果是自助数据：
零，平均长度，编解码器ID，块计数，十六进制=解包（“HLBBs*”，self.data）
打印“测试”
self.Hexline=binascii.hexlify（Hexline）
self.blockCount=blockCount
self.AVL=0#AVL？看起来像是数据读取光标
继续=0
AVLBlockPos=0
继续1:#Daten empfangen和die DB schreiben
#dbgps.DBsendAlchemy（“更新容器gps集lon='”+str（数据['lon']）+”，lat='“+str（数据['lat']）+”，richtong='“+str（数据['gpscorse']）+”，Timestamp='“+str（int（数据['Timestamp']）+”，其中IMEI='“+str（数据['IMEI]+”）
#睡眠时间（0.2）
打印str（数据['Lon']）
self.sensorsDataLocks.append（数据）
除ValueError外，e：
self.dataBreak+=1
自动重新读取数据（十六进制）
如果self.dataBreak>self.possibleBreakCount：
self.error.append（“数据中断”）
自我成功=错误
返回
其他：
self.AVL=AVLBlockPos
继续-=1
继续+=1
AVLBlockPos=self.AVL
其他：
self.error.append（“未收到数据”）
自我成功=错误
def readData（自身，长度=8192）：
数据=self.socket.recv（长度）
self.raw+=数据
返回数据
def重新读取数据（自身、六角线）：
HexlineNew=unpack（“s*”，self.readData（））
Hexline+=HexlineNew[0]
self.Hexline=binascii.hexlify（Hexline）
def proceedBlockData（自身）：
DateV='0x'+self.extract（16）
日期=四舍五入（长（日期V，16）/1000，0）
Prio=self.extract\u int（2）
GpsLon=self.extract\u int（8）
GpsLat=self.extract\u int（8）
Lon=str（浮动（GpsLon）/10000000）
Lat=str（浮动（GpsLat）/10000000）
GpsH=self.extract\u int（4）
gpscorse=self.extract\u int（4）
GpsSat=self.extract_int（2）
GpsSpeed=self.extract\u int（4）
IOEventCode=self.extract\u int（2）
NumOfIO=self.extract\u int（2）
sensorDataResult={}
pais_计数=0
因为[1,2,4,8]中的i：
pc=0
数据=自读传感器数据字节（i）
对于data.keys（）中的iocode：
pais_计数+=1
sensorDataResult[iocode]=数据[iocode]
pc+=1
#返回{'imei'：self.imei，'date'：DateS，'Lon'：Lon，'Lat'：Lat，'GpsSpeed'：GpsSpeed，'gpscorse'：gpscorse，'sensorData'：sensorDataResult}
返回{'IMEI'：self.IMEI，'Timestamp'：DateS，'Lon'：Lon，'Lat'：Lat，'GpsSpeed'：GpsSpeed，'gpscorse'：gpscorse}
def readSensorDataBytes（自身，计数）：
结果={}
pairscont=self.extract\u int（2）
i=1
而我知道你的数据（在结构中）是什么样子的？也许你也可以看看这个问题（除非你已经问过了）：对不起，我反应太晚了。我可以解决这个问题，我的问题是套接字连接，但我不知道我的raspberry和我的ubuntu服务器在套接字端有什么区别。