config.ini
[network]
SERVER_PORT = 4040
[db]
DB_HOST = 10.20.1.129
USER = sa
PWD = skcl@2013
DATABASE = CDMTCP
[gpsdata]
DATA_FROM_DB = True
IS_USE_LANES = True
ROAD_GPS_FILE = roadgps.txt
ROAD_ARC_FILE = arcinfo.txt
[parameter]
IS_USE_VALID_PERIOD = False
TIME_UPPER_LIMIT = 18
TIME_LOWER_LIMIT = 6
COFFEE = 0.0001
DO_UPDATE = True
dbManager.py
# -*- coding:gbk -*-
# auther : pdm
# email : ppppdm@gmail.com
try:
import pyodbc
except:
print('no module pyodbc, should init first!')
import threading
import time
# self module
import myLog
import globalConfig
DB_HOST = '10.20.1.200' # '210.73.152.201'
USER = 'sa'
PWD = 'sa'
DATABASE = 'CDMTCP'
DB_CONNECT_LOCK = threading.Lock()
MAX_DB_CONNECT = 1000
DB_CONNECT_NOT_USE_LIST = list()
DB_CONNECT_USED_LIST = list()
def init_db_connect_list(conn_num = MAX_DB_CONNECT):
for i in range(conn_num):
try:
db_conn = pyodbc.connect('DRIVER={SQL Server}', host = DB_HOST, user = USER, password = PWD, database = DATABASE)
# lock
DB_CONNECT_LOCK.acquire()
DB_CONNECT_NOT_USE_LIST.append(db_conn)
# release lock
DB_CONNECT_LOCK.release()
except: # not print db execption yet
myLog.mylogger.error('init db got an error!')
print('init db got an error!')
break
print('init db conn done! connections :', len(DB_CONNECT_NOT_USE_LIST))
myLog.mylogger.debug('init db conn done!')
return
def get_one_db_connect():
db_conn = None
try:
# lock
DB_CONNECT_LOCK.acquire()
db_conn = DB_CONNECT_NOT_USE_LIST.pop()
DB_CONNECT_USED_LIST.append(db_conn)
# release lock
DB_CONNECT_LOCK.release()
except ValueError:
print('not enough db_conn!')
myLog.mylogger.error('not enough db_conn!')
except Exception as e:
print(e)
myLog.mylogger.error(e)
return db_conn
def close_one_db_connect(conn):
if conn:
# if the conn is usable
try:
conn.commit()
except : # not print db except yet
print('connect can not used')
# lock
DB_CONNECT_LOCK.acquire()
DB_CONNECT_USED_LIST.remove(conn)
# release lock
DB_CONNECT_LOCK.release()
return
try:
# lock
DB_CONNECT_LOCK.acquire()
DB_CONNECT_USED_LIST.remove(conn)
DB_CONNECT_NOT_USE_LIST.append(conn)
# release lock
DB_CONNECT_LOCK.release()
except Exception as e:
print(e)
myLog.mylogger.error(e)
return
def get_db_connect():
db_conn = None
try:
db_conn = pyodbc.connect('DRIVER={SQL Server}', host = DB_HOST, user = USER, password = PWD, database = DATABASE)
except: # not print db execption yet
myLog.mylogger.debug('init db got an error!')
print('init db got an error!')
return db_conn
def close_db_connect(db_conn):
if db_conn:
db_conn.close()
DB_REPAIR_TIME = 3600 # sec
def db_connect_server():
# check the useable db connect number in the db connect list every one hour
while True:
time.sleep(DB_REPAIR_TIME)
# lock
DB_CONNECT_LOCK.acquire()
total_conn = len(DB_CONNECT_NOT_USE_LIST) + len(DB_CONNECT_USED_LIST)
# release lock
DB_CONNECT_LOCK.release()
print('total db connect :', total_conn)
if total_conn < (MAX_DB_CONNECT >> 1):
init_db_connect_list(MAX_DB_CONNECT - total_conn)
return
def init_db():
# init db args
global SERVER_PORT, DB_HOST, USER, PWD
SERVER_PORT = globalConfig.SERVER_PORT
DB_HOST = globalConfig.DB_HOST
USER = globalConfig.USER
PWD = globalConfig.PWD
# do two things
# one to init db connect list(db connect pool)
t1 = threading.Thread(target=init_db_connect_list)
t1.start()
# two to start db connect repair service
t2 = threading.Thread(target=db_connect_server)
t2.start()
return
dbUpdater.py
# -*- coding:gbk -*-
# auther : pdm
# email : ppppdm@gmail.com
# 专门处理 update 数据库表的工作线程/进程
import queue
import dbManager
import time
# 用于缓存其他处理线程sql语句的队列
q = queue.Queue()
def update_db_server():
if_sql = "if not exists( select * from tbl_heartbeatinfo_new where camera_id = ?)"
insert_sql = "insert into tbl_heartbeatinfo_new (id, camera_id, gpx, gpy, gpstime, roadname, mph, createtime) values ( newid(),?,?,?,?,?,?,?)"
else_sql = "else update tbl_heartbeatinfo_new set gpx = ?, gpy = ?, gpstime = ?, roadname = ?, mph = ?, createtime = ? where (camera_id = ?)"
sql = if_sql+insert_sql+else_sql
conn = dbManager.get_db_connect()
cur = conn.cursor()
arg_list = list()
print('update_db_server running')
time_wait = 1
get_num =100
while True:
#print('in while update db')
for i in range(get_num):
try:
gpx, gpy, gpstime, roadname, mph, createtime, camera_id = q.get(False)
q.task_done()
sql_param = (camera_id, camera_id, gpx, gpy, gpstime, roadname, mph, createtime, gpx, gpy, gpstime, roadname, mph, createtime, camera_id)
arg_list.append(sql_param)
except queue.Empty:
print('empty')#
get_num = max(5, len(arg_list))
break
if get_num == len(arg_list):
get_num += 10
#print(gpx, gpy, gpstime, roadname, mph, createtime, camera_id)
#print(arg_list)
if len(arg_list) != 0:
#print(arg_list)
try:
start = time.time()
cur.executemany(sql, arg_list)
conn.commit()
end = time.time()
print('execute success, time :', end - start)
except:
print('update db excute error!\n')
arg_list.clear()
print('time_wait', time_wait, 'get_num', get_num)
time.sleep(time_wait)
dbManager.close_db_connect(conn)
return
globalConfig.py
# -*- coding:gbk -*-
# auther : pdm
# email : ppppdm@gmail.com
import configparser
import dbManager
network_ops = ['SERVER_PORT']
db_ops = ['DB_HOST', 'USER', 'PWD', 'DATABASE']
gpsdata_ops = ['ROAD_GPS_FILE']
parameter_ops = ['TIME_UPPER_LIMIT', 'TIME_LOWER_LIMIT', 'COFFEE']
sections = {'network':network_ops, 'db':db_ops, 'gpsdata':gpsdata_ops, 'parameter':parameter_ops}
# Global Values (default value)
# network
SERVER_PORT = 44444
# db
#DB_HOST = '10.20.1.200' # '210.73.152.201'
#USER = 'sa'
#PWD = 'sa'
#DATABASE = 'CDMTCP'
# gpsdata
ROAD_GPS_FILE = 'roadgps.txt'
ROAD_ARC_FILE = 'arcinfo.txt'
#
import processData
import readRoadGPS
import processDB
def readConfig():
global SERVER_PORT, ROAD_GPS_FILE, ROAD_ARC_FILE
cf = configparser.ConfigParser()
cf.read('config.ini')
cf.sections()
SERVER_PORT = cf.getint('network', 'SERVER_PORT')
dbManager.DB_HOST = cf.get('db', 'DB_HOST')
dbManager.USER = cf.get('db', 'USER')
dbManager.PWD = cf.get('db', 'PWD')
dbManager.DATABASE = cf.get('db', 'DATABASE')
ROAD_GPS_FILE = cf.get('gpsdata', 'ROAD_GPS_FILE')
ROAD_ARC_FILE = cf.get('gpsdata', 'ROAD_ARC_FILE')
processData.TIME_UPPER_LIMIT = cf.getint('parameter', 'TIME_UPPER_LIMIT')
processData.TIME_LOWER_LIMIT = cf.getint('parameter', 'TIME_LOWER_LIMIT')
processData.COFFEE = cf.getfloat('parameter', 'COFFEE')
processData.IS_USE_LANES = cf.getboolean('gpsdata', 'IS_USE_LANES')
processData.IS_USE_VALID_PERIOD = cf.getboolean('parameter', 'IS_USE_VALID_PERIOD')
processDB.DO_UPDATE = cf.getboolean('parameter', 'DO_UPDATE')
readRoadGPS.DATA_FROM_DB = cf.getboolean('gpsdata', 'DATA_FROM_DB')
print('SERVER_PORT:', SERVER_PORT)
print('DB:', dbManager.DB_HOST, dbManager.USER, dbManager.PWD, dbManager.DATABASE)
print('ROAD_GPS_FILE:', ROAD_GPS_FILE)
print('ROAD_ARC_FILE:', ROAD_ARC_FILE)
print('Read Config Done')
if __name__=='__main__':
readConfig()
heartBeatServer.py
# -*- coding:gbk -*-
# auther : pdm
# email : ppppdm@gmail.com
import socket
import threading
import traceback
import sys
#import multiprocessing
# self module
import processData
import dbManager
import myLog
import globalConfig
import processDB
# Global Variables
INADDR_ANY = '0.0.0.0' # OR INADDR_ANY = ''
HOST = INADDR_ANY # socket.gethostbyname(socket.gethostname()) #socket.INADDR_ANY
#SERVER_PORT = 44444
client_list = list()
list_lock = threading.Lock()
#client_list = multiprocessing.Manager().list()
#list_lock = multiprocessing.Lock()
def insert_list(id):
list_lock.acquire()
client_list.append(id)
list_lock.release()
return
def remove_list(id):
list_lock.acquire()
client_list.remove(id)
list_lock.release()
return
def total_in_list():
list_lock.acquire()
total = len(client_list)
list_lock.release()
return total
def do_init():
dbconn = None
cur = None
dbconn = dbManager.get_db_connect()
if dbconn:
cur = dbconn.cursor()
insert_list(threading.get_ident())
return dbconn, cur
def do_finish(dbconn, cur, sock):
if dbconn:
cur.close()
dbManager.close_db_connect(dbconn)
remove_list(threading.get_ident())
# close socket
sock.close()
return
def handleConnect(sock, addr):
dbconn, cur = do_init()
print('total connect:', total_in_list())
myLog.mylogger.error('total connect:%s', total_in_list())
while True:
try:
b_data = sock.recv(1024)
if b_data == b'':
print('reomte closed!')
sock.close()
break
#print(len(b_data), b_data)
myLog.mylogger.debug('recv %s %s %s',addr[0], addr[1], str(b_data))
# process data
r_data, infos = processData.process_data(b_data)
sock.send(r_data)
# proecss db
processDB.process_db(infos, dbconn, cur)
except:
# should not get error while print exception
print(traceback.format_exc())
myLog.mylogger.error(traceback.format_exc())
break
do_finish(dbconn, cur, sock)
print('left connect:', total_in_list())
myLog.mylogger.error('left connect:%s', total_in_list())
return
def Server():
PORT = globalConfig.SERVER_PORT
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print(HOST, PORT)
sock.bind((HOST, PORT))
sock.listen(5)
print('main server ready to accept...')
while True:
conn, addr = sock.accept()
print('connected by ', addr)
try:
t = threading.Thread(target=handleConnect, args=(conn, addr))
t.start()
#p = multiprocessing.Process(target=handleConnect, args=(conn, addr))
#p.start()
except RuntimeError as e:
print(e)
myLog.mylogger.error(e)
except:
print(traceback.format_exc())
myLog.mylogger.error(traceback.format_exc())
# if server error exit
sys.exit()
if __name__=='__main__':
import os
print(__file__, 'test')
os.system('pause')
MainEntry.py
# -*- coding:gbk -*-
# auther : pdm
# email : ppppdm@gmail.com
import threading
# import self module
import heartBeatServer
import remoteControlServer
#import dbManager
import readRoadGPS
import globalConfig
import dbUpdater
if __name__=='__main__':
# init global values from config file
globalConfig.readConfig()
# init database
#dbManager.init_db()
# init road data
#readRoadGPS.initRoadGPS(globalConfig.ROAD_GPS_FILE)
readRoadGPS.initRoadInfo()
t = threading.Thread(target=heartBeatServer.Server)
t.start()
t = threading.Thread(target=remoteControlServer.Server)
t.start()
t = threading.Thread(target=dbUpdater.update_db_server)
t.start()
processData.py
# -*- coding:gbk -*-
# auther : pdm
# email : ppppdm@gmail.com
import traceback
import datetime
# self module
import myLog
import readRoadGPS
import dbUpdater
TIME_UPPER_LIMIT = 18
TIME_LOWER_LIMIT = 6
HEART_BEAT_PACKAGE_ITEM = ['HEAD', 'MAC', 'GPS STATUS', 'GPS DATE', 'GPS TIME',
'X', 'Y', 'GPS SPEED', 'GPS DIRCT', 'WORK MODE',
'SERVER IP', 'DEVICE IP', 'HB INTERVAL', 'UPLOAD NUM','TRACK NUM',
'CAR DEFAULT RANGE', 'COMPRESSION FACTOR', 'END'
]
HEART_BEAT_PACKAGE_ITEM_LEN_old =[2 , 12, 1, 8, 6,
10, 11, 5, 2, 1,
15, 15, 2, 1, 1,
4, 2, 2
]
HEART_BEAT_PACKAGE_ITEM_LEN = {'HEAD':2, 'MAC':12, 'GPS STATUS':1, 'GPS DATE':8, 'GPS TIME':6,
'X':10, 'Y':11, 'GPS SPEED':5, 'GPS DIRCT':2, 'WORK MODE':1,
'SERVER IP':15, 'DEVICE IP':15, 'HB INTERVAL':2, 'UPLOAD NUM':1,'TRACK NUM':1,
'CAR DEFAULT RANGE':4, 'COMPRESSION FACTOR':2, 'END':2 }
RETURN_PACKAGE_ITEM = ['HEAD', 'CMD', 'WORK MODE', 'SERVER IP', 'DEVICE IP',
'HB INTERVAL', 'UPLOAD NUM', 'TRACK NUM', 'CAR DEFAULT RANGE', 'COMPRESSION FACTOR',
'IS IN LANES', 'IS IN VALID PERIOD', 'END'
]
RETURN_PACKAGE_ITEM_LEN = [2, 1, 1, 15, 15,
2, 1, 1, 4, 2,
1, 1, 2
]
DEFALUT_PACKAGE_CONTENT = {'HEAD':b'\xaa\x55', 'CMD':b'0', 'WORK MODE':b'0', 'SERVER IP':b'000.000.000.000', 'DEVICE IP':b'000.000.000.000',
'HB INTERVAL':b'05', 'UPLOAD NUM':b'4', 'TRACK NUM':b'4', 'CAR DEFAULT RANGE':b'0815', 'COMPRESSION FACTOR':b'70',
'IS IN LANES':b'0', 'IS IN VALID PERIOD':b'0', 'END':b'\xee\x55'
}
COFFEE = 0.0001
IS_USE_LANES = False
IS_USE_VALID_PERIOD = False
DO_UPDATE = False
ROAD_TIME_TYPE_Daytime = '8a9481d03f79b7d6013f7a0948310002'
ROAD_TIME_TYPE_Tidal= '8a9481d03f79b7d6013f7a0948310003'
###################################################################################3
def get_next_item(b_data, i, t):
return b_data[t:t+i]
def changeToFormate(data):
'12-34-56-78-90-ab'
data = data[0:2] + '-' + data[2:4] + '-' + data[4:6] + '-' + data[6:8] + '-' + data[8:10] + '-' + data[10:12]
return data
def get_road_id_from_location(location):
road_id = ''
try:
# the location format is ddmm.mmmm dddmm.mmmm
x = float(location[0])
y = float(location[1])
except:
myLog.mylogger.error('camera location value error! x:%s y:%s'%(location[0][:-1], location[1][:-1]))
x, y = 0, 0
# the unit of COFFEE is degree, the minute of mCOFFEE = 60*COFFEE
mCOFFEE = 60*COFFEE
for p in readRoadGPS.ROAD_GPS_POINT_LIST:
try:
rX = float(p[0])
rY = float(p[1])
except:
myLog.mylogger.error('road gps value error! rX:%s rY:%s'%(p[0], p[1]))
rX , rY = 0, 0
try:
rID = p[2]
except:
myLog.mylogger.error('road gps have no name')
rID = ''
if rX - mCOFFEE < x and x < rX + mCOFFEE and rY - mCOFFEE < y and y < rY + mCOFFEE:
road_id = rID
return road_id
return road_id
def get_road_arcinfo_by_id(road_id):
if road_id == '':
return None
arc_info = None
for i in readRoadGPS.ROAD_ARC_INFO_LIST:
if road_id == i[0]:
arc_info = i
return arc_info
def decode_data(b_data):
#s = ''
infos = {}
t = 2 # skip head and end
for i in HEART_BEAT_PACKAGE_ITEM[1:-1]:
item_len = HEART_BEAT_PACKAGE_ITEM_LEN[i]
b_item = get_next_item(b_data, item_len, t)
try:
if i == 'X' or i == 'Y':
b_item = b_item[:-1]
# convert to str
item = str(b_item, 'gbk')
if i == 'MAC':
item = changeToFormate(item)
#s += item + '\t'
infos[i] = item
except:
#print(traceback.format_exc())
myLog.mylogger.error(traceback.format_exc())
t+=item_len
# get the road ID info if is in lanes
try:
location = (infos['X'], infos['Y'])
except:
location = (0.0, 0.0)
road_id = get_road_id_from_location(location)
infos['ROAD_ID'] = road_id
# get road arcinfo by road ID
arcinfo = get_road_arcinfo_by_id(road_id)
if arcinfo:
infos['ROAD STATUS'] = arcinfo[1]
infos['ROAD'] = arcinfo[2]
infos['ROAD TIME_TYPE'] = arcinfo[3]
infos['ROAD TIME'] = arcinfo[4]
infos['ROAD sTIME'] = arcinfo[5]
infos['ROAD eTIME'] = arcinfo[6]
#myLog.mylogger.debug(s)
myLog.mylogger.debug(infos)
return infos
###################################################################################3
def is_in_lanes(location):
if IS_USE_LANES == False:
# if not use lanes, always return true
return True
try:
# the location from camera should be transform from ddmm.mmmm to dd.dddddddd..
#xd = float(location[0][:2])
#xm = float(location[0][2:])
#yd = float(location[1][:3])
#ym = float(location[1][3:])
#x = xd + xm/60
#y = yd + ym/60
# the location format is ddmm.mmmm dddmm.mmmm
x = float(location[0])
y = float(location[1])
except:
myLog.mylogger.error('camera location value error! x:%s y:%s'%(location[0][:-1], location[1][:-1]))
x, y = 0, 0
# the unit of COFFEE is degree, the minute of mCOFFEE = 60*COFFEE
mCOFFEE = 60*COFFEE
for p in readRoadGPS.ROAD_GPS_POINT_LIST:
try:
rX = float(p[0])
rY = float(p[1])
except:
myLog.mylogger.error('road gps value error! rX:%s rY:%s'%(p[0], p[1]))
rX , rY = 0, 0
if rX - mCOFFEE < x and x < rX + mCOFFEE and rY - mCOFFEE < y and y < rY + mCOFFEE:
print('camera in lanes')
myLog.mylogger.debug('camera in lanes')
return True
print('camera not in lanes')
myLog.mylogger.debug('camera not in lanes')
return False
def is_valid_period():
if IS_USE_VALID_PERIOD == False:
# if not use valid preiod, always reutrn true
return True
# valid period is 6:00 to 18:00
tn = datetime.datetime.now().time()
tu = datetime.time(TIME_UPPER_LIMIT)
tl = datetime.time(TIME_LOWER_LIMIT)
if tn <= tu and tn >= tl:
print('camera in valid_period')
myLog.mylogger.debug('camera in valid_period')
return True
print('camera not in valid_period')
myLog.mylogger.debug('camera not in valid_period')
return False
def is_in_lanes_new(infos):
if IS_USE_LANES == False:
# if not use lanes, always return true
return True
road_id = infos['ROAD_ID']
if road_id != '':
road_status = infos['ROAD STATUS']
if road_status == 0:
return True
return False
def get_time_last(time_str):
time_arr = time_str.split('至')
low = time_arr[0].split(':')
up = time_arr[1].split(':')
try:
l_time = datetime.time(int(low[0]),int(low[1]))
u_time = datetime.time(int(up[0]),int(up[1]))
return l_time,u_time
except:
l_time = datetime.time(0)
u_time = datetime.time(0)
return l_time,u_time
def is_valid_period_new(infos):
if IS_USE_VALID_PERIOD == False:
# if not use valid preiod, always reutrn true
return True
road_id = infos['ROAD_ID']
if road_id != '':
road_status = infos['ROAD STATUS']
if road_status == 0:
road_time_type = infos['ROAD TIME_TYPE']
if road_time_type == ROAD_TIME_TYPE_Tidal:
tn = datetime.datetime.now().time()
print(road_time_type)
limit_stime = infos['ROAD sTIME']
limit_etime = infos['ROAD eTIME']
lsl,lsu = get_time_last(limit_stime)
lel,leu = get_time_last(limit_etime)
if ( lsl < tn and tn < lsu) or (lel < tn and leu):
return True
if road_time_type == ROAD_TIME_TYPE_Daytime:
tn = datetime.datetime.now().time()
print(road_time_type)
road_time = infos['ROAD TIME']
rtl, rtu = get_time_last(road_time)
if rtl < tn and tn < rtu:
return True
return False
def encode_return_data(infos, changed_args=dict()):
r_data = bytearray()
modify_items = {}
# judge wether in the lanes
#location = (infos['X'], infos['Y'])
#if is_in_lanes(location):
# modify_items['IS IN LANES']=b'1'
if is_in_lanes_new(infos):
modify_items['IS IN LANES']=b'1'
# judeg wether in valid period
#if is_valid_period():
# modify_items['IS IN VALID PERIOD']=b'1'
if is_valid_period_new(infos):
modify_items['IS IN VALID PERIOD']=b'1'
# CMD
if len(changed_args) != 0:
modify_items['CMD'] = b'1'
# Server IP
if 'SERVER IP' in changed_args:
modify_items['SERVER IP'] = changed_args['SERVER IP'] # should have 15 chars
else:
modify_items['SERVER IP'] = bytes(infos.get('SERVER IP','000.000.000.000'), 'gbk')
# HB INTERVAL
if 'HB INTERVAL' in changed_args:
modify_items['HB INTERVAL'] = changed_args['HB INTERVAL']
else:
modify_items['HB INTERVAL'] = bytes(infos['HB INTERVAL'], 'gbk')
# UPLOAD NUM
if 'UPLOAD NUM' in changed_args:
modify_items['UPLOAD NUM'] = changed_args['UPLOAD NUM']
else:
modify_items['UPLOAD NUM'] = bytes(infos['UPLOAD NUM'], 'gbk')
# TRACK NUM
if 'TRACK NUM' in changed_args:
modify_items['TRACK NUM'] = changed_args['TRACK NUM']
else:
modify_items['TRACK NUM'] = bytes(infos['TRACK NUM'], 'gbk')
# CAR DEFAULT RANGE
if 'CAR DEFAULT RANGE' in changed_args:
modify_items['CAR DEFAULT RANGE'] = changed_args['CAR DEFAULT RANGE']
else:
modify_items['CAR DEFAULT RANGE'] = bytes(infos['CAR DEFAULT RANGE'], 'gbk')
# COMPRESSION FACTOR
if 'COMPRESSION FACTOR' in changed_args:
modify_items['COMPRESSION FACTOR'] = changed_args['COMPRESSION FACTOR']
else:
modify_items['COMPRESSION FACTOR'] = bytes(infos['COMPRESSION FACTOR'], 'gbk')
for i in RETURN_PACKAGE_ITEM:
if i not in modify_items:
r_data += DEFALUT_PACKAGE_CONTENT[i]
else:
r_data += modify_items[i]
#print(r_data)
myLog.mylogger.debug(r_data)
return r_data
###################################################################################3
def store_to_db(infos, conn, cur):
if conn and cur:
try:
gpstime = datetime.datetime.strptime(infos['GPS DATE']+infos['GPS TIME'], '%Y%m%d%H%M%S')
except:
gpstime = datetime.datetime.now()
try:
mph = float(infos.get('GPS SPEED', '0'))
except:
mph = 0
try:
hb_interval = float(infos.get('HB INTERVAL', '5'))
except:
hb_interval = 5
try:
upload_num = int(infos.get('UPLOAD NUM', '3'))
except:
upload_num = 3
try:
track_num = int(infos.get('TRACK NUM', '3'))
except:
track_num = 3
try:
compression_factor = float(infos.get('COMPRESSION FACTOR', '5'))
except:
compression_factor = 3
camera_id = infos.get('MAC', 'ID error')
x = infos.get('X', 'X error')
y = infos.get('Y', 'Y error')
road = infos.get('ROAD', '')
direction = infos.get('GPS DIRCT', 'ss')
car_distance = infos.get('CAR DEFAULT RANGE', '')
createtime = datetime.datetime.now()
print(gpstime, camera_id, x, y, road, mph)
myLog.mylogger.debug('%s %s %s %s %s %s', gpstime, camera_id, x, y, road, mph)
try:
cur.execute("INSERT INTO tbl_heartbeatinfo( ID, camera_id, gpx, gpy, gpstime, roadname, mph, createtime, direction, hb_interval, upload_num, track_num, car_distance, compression_factor) VALUES (newid(), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
(camera_id, x, y, gpstime, road, mph, createtime, direction, hb_interval, upload_num, track_num, car_distance, compression_factor))
except:
myLog.mylogger.error('db excute error! %s\n', infos)
print('db excute error!\n')
return
try:
conn.commit()
myLog.mylogger.debug('store to db success!')
except:
myLog.mylogger.error('commit error! %s\n', infos)
print('commit erorr!')
return
def update_to_heartbeatinfo_new(infos, conn, cur):
if conn and cur:
try:
gpstime = datetime.datetime.strptime(infos['GPS DATE']+infos['GPS TIME'], '%Y%m%d%H%M%S')
except:
gpstime = datetime.datetime.now()
try:
mph = float(infos.get('GPS SPEED', '0'))
except:
mph = 0
'''
try:
hb_interval = float(infos.get('HB INTERVAL', '0'))
except:
hb_interval = 5
try:
upload_num = int(infos.get('UPLOAD NUM', '0'))
except:
upload_num = 3
try:
track_num = int(infos.get('TRACK NUM', '0'))
except:
track_num = 3
try:
compression_factor = float(infos.get('COMPRESSION FACTOR', '0'))
except:
compression_factor = 3
'''
camera_id = infos.get('MAC', '')
gpx = infos.get('X', '')
gpy = infos.get('Y', '')
roadname = infos.get('ROAD', '')
#direction = infos.get('GPS DIRCT', '')
#car_distance = infos.get('CAR DEFAULT RANGE', '')
createtime = datetime.datetime.now()
#print(gpstime, camera_id, gpx, gpy, road, mph)
#myLog.mylogger.debug('%s %s %s %s %s %s', gpstime, camera_id, x, y, road, mph)
try:
sql = "update tbl_heartbeatinfo_new set gpx = ?, gpy = ?, gpstime = ?, roadname = ?, mph = ?, createtime = ? where (camera_id = ?)"
cur.execute(sql, gpx, gpy, gpstime, roadname, mph, createtime, camera_id)
except:
myLog.mylogger.error('db excute error! %s\n', infos)
print('db excute error!\n')
return
try:
conn.commit()
myLog.mylogger.debug('store to db success!')
except:
myLog.mylogger.error('commit error! %s\n', infos)
print('commit erorr!')
return
def put_to_dbUpdater_quuee(infos):
#sql = "update tbl_heartbeatinfo_new set gpx = ?, gpy = ?, gpstime = ?, roadname = ?, mph = ?, createtime = ? where (camera_id = ?)"
try:
gpstime = datetime.datetime.strptime(infos['GPS DATE']+infos['GPS TIME'], '%Y%m%d%H%M%S')
except:
gpstime = datetime.datetime.now()
try:
mph = float(infos.get('GPS SPEED', '0'))
except:
mph = 0
camera_id = infos.get('MAC', '')
gpx = infos.get('X', '')
gpy = infos.get('Y', '')
roadname = infos.get('ROAD', '')
createtime = datetime.datetime.now()
dbUpdater.q.put((gpx, gpy, gpstime, roadname, mph, createtime, camera_id))
return
# @ primary
def process_data(b_data):
# decode
infos = decode_data(b_data)
# store to db
#store_to_db(infos, dbconn, cur)
# update data to heartbeatinfo_new
#if DO_UPDATE:
#update_to_heartbeatinfo_new(infos, dbconn, cur)
# put_to_dbUpdater_quuee(infos)
# encode
r_data = encode_return_data(infos)
return r_data, infos
#
processDB.py
# -*- coding:gbk -*-
# auther : pdm
# email : ppppdm@gmail.com
DO_UPDATE = False
import datetime
import myLog
import dbUpdater
def store_to_db(infos, conn, cur):
if conn and cur:
try:
gpstime = datetime.datetime.strptime(infos['GPS DATE']+infos['GPS TIME'], '%Y%m%d%H%M%S')
except:
gpstime = datetime.datetime.now()
try:
mph = float(infos.get('GPS SPEED', '0'))
except:
mph = 0
try:
hb_interval = float(infos.get('HB INTERVAL', '5'))
except:
hb_interval = 5
try:
upload_num = int(infos.get('UPLOAD NUM', '3'))
except:
upload_num = 3
try:
track_num = int(infos.get('TRACK NUM', '3'))
except:
track_num = 3
try:
compression_factor = float(infos.get('COMPRESSION FACTOR', '5'))
except:
compression_factor = 3
camera_id = infos.get('MAC', 'ID error')
x = infos.get('X', 'X error')
y = infos.get('Y', 'Y error')
road = infos.get('ROAD', '')
direction = infos.get('GPS DIRCT', 'ss')
car_distance = infos.get('CAR DEFAULT RANGE', '')
createtime = datetime.datetime.now()
print(gpstime, camera_id, x, y, road, mph)
myLog.mylogger.debug('%s %s %s %s %s %s', gpstime, camera_id, x, y, road, mph)
try:
cur.execute("INSERT INTO tbl_heartbeatinfo( ID, camera_id, gpx, gpy, gpstime, roadname, mph, createtime, direction, hb_interval, upload_num, track_num, car_distance, compression_factor) VALUES (newid(), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
(camera_id, x, y, gpstime, road, mph, createtime, direction, hb_interval, upload_num, track_num, car_distance, compression_factor))
except:
myLog.mylogger.error('db excute error! %s\n', infos)
print('db excute error!\n')
return
try:
conn.commit()
myLog.mylogger.debug('store to db success!')
except:
myLog.mylogger.error('commit error! %s\n', infos)
print('commit erorr!')
return
def update_to_heartbeatinfo_new(infos, conn, cur):
if conn and cur:
try:
gpstime = datetime.datetime.strptime(infos['GPS DATE']+infos['GPS TIME'], '%Y%m%d%H%M%S')
except:
gpstime = datetime.datetime.now()
try:
mph = float(infos.get('GPS SPEED', '0'))
except:
mph = 0
'''
try:
hb_interval = float(infos.get('HB INTERVAL', '0'))
except:
hb_interval = 5
try:
upload_num = int(infos.get('UPLOAD NUM', '0'))
except:
upload_num = 3
try:
track_num = int(infos.get('TRACK NUM', '0'))
except:
track_num = 3
try:
compression_factor = float(infos.get('COMPRESSION FACTOR', '0'))
except:
compression_factor = 3
'''
camera_id = infos.get('MAC', '')
gpx = infos.get('X', '')
gpy = infos.get('Y', '')
roadname = infos.get('ROAD', '')
#direction = infos.get('GPS DIRCT', '')
#car_distance = infos.get('CAR DEFAULT RANGE', '')
createtime = datetime.datetime.now()
#print(gpstime, camera_id, gpx, gpy, road, mph)
#myLog.mylogger.debug('%s %s %s %s %s %s', gpstime, camera_id, x, y, road, mph)
try:
sql = "update tbl_heartbeatinfo_new set gpx = ?, gpy = ?, gpstime = ?, roadname = ?, mph = ?, createtime = ? where (camera_id = ?)"
cur.execute(sql, gpx, gpy, gpstime, roadname, mph, createtime, camera_id)
except:
myLog.mylogger.error('db excute error! %s\n', infos)
print('db excute error!\n')
return
try:
conn.commit()
myLog.mylogger.debug('store to db success!')
except:
myLog.mylogger.error('commit error! %s\n', infos)
print('commit erorr!')
return
def put_to_dbUpdater_quuee(infos):
#sql = "update tbl_heartbeatinfo_new set gpx = ?, gpy = ?, gpstime = ?, roadname = ?, mph = ?, createtime = ? where (camera_id = ?)"
try:
gpstime = datetime.datetime.strptime(infos['GPS DATE']+infos['GPS TIME'], '%Y%m%d%H%M%S')
except:
gpstime = datetime.datetime.now()
try:
mph = float(infos.get('GPS SPEED', '0'))
except:
mph = 0
camera_id = infos.get('MAC', '')
gpx = infos.get('X', '')
gpy = infos.get('Y', '')
roadname = infos.get('ROAD', '')
createtime = datetime.datetime.now()
dbUpdater.q.put((gpx, gpy, gpstime, roadname, mph, createtime, camera_id))
return
# @ primary
def process_db(infos, dbconn, cur):
# store to db
store_to_db(infos, dbconn, cur)
# update data to heartbeatinfo_new
if DO_UPDATE:
#update_to_heartbeatinfo_new(infos, dbconn, cur)
put_to_dbUpdater_quuee(infos)
return
readRoadGPS.py
# -*- coding:gbk -*-
# auther : pdm
# email : ppppdm@gmail.com
import dbManager
import globalConfig
DATA_FROM_DB = False
ROAD_GPS_POINT_LIST = list()
ROAD_ARC_INFO_LIST = list()
def set_list(data_str):
l = list()
coor_arr = data_str.split('\n')
for i in coor_arr:
point = i.split(',')
l.append(point)
return l
def initRoadGPS(filename):
global ROAD_GPS_POINT_LIST
try:
f = open(filename, 'rt')
data = f.read()
# set ROAD_GPS_POINT_LIST with data
ROAD_GPS_POINT_LIST = set_list(data)
f.close()
print('Read road gps from file done')
except Exception as e:
print(e)
def initRoadArc(filename):
global ROAD_ARC_INFO_LIST
try:
f = open(filename, 'rt')
data = f.read()
# set ROAD_GPS_POINT_LIST with data
ROAD_ARC_INFO_LIST = set_list(data)
f.close()
print('Read road arc info from file done')
except Exception as e:
print(e)
def read_data_from_file():
initRoadGPS(globalConfig.ROAD_GPS_FILE)
initRoadArc(globalConfig.ROAD_ARC_FILE)
def initRoadGPS_db(cur):
global ROAD_GPS_POINT_LIST
# read arcpoints
try:
cur.execute("select LATITUDE, LONGITUDE, ARC_ID from t_arcpoints")
ROAD_GPS_POINT_LIST = cur.fetchall()
return True
except:
return False
def initRoadArc_db(cur):
global ROAD_ARC_INFO_LIST
# read arcinfo
try:
cur.execute("select ID,status,Road_Name,backup1,backup2,Limit_stime,Limit_etime from t_arcinfo")
ROAD_ARC_INFO_LIST = cur.fetchall()
return True
except:
return False
def read_data_from_db():
ret = False
conn = dbManager.get_db_connect()
if conn:
cur = conn.cursor()
# read arcpoints & # read arcinfo
if initRoadGPS_db(cur) and initRoadArc_db(cur):
print('Read gps info from db done!')
ret = True
else:
ret = False
dbManager.close_db_connect(conn)
return ret
def initRoadInfo():
print('DATA_FROM_DB', DATA_FROM_DB)
if DATA_FROM_DB:
if read_data_from_db() != True:
read_data_from_file()
else:
read_data_from_file()
if __name__=='__main__':
#initRoadGPS('roadgps_hefei.txt')
print(ROAD_GPS_POINT_LIST)