def __init__(self, tool_id):
self.tool_id = tool_id
self.db = DBHelper()
self.tool = None
self.tool_type = None
self.dimension_id = []
self.dimension_name = []
def __init__(self, cutter_info_dict, tool_type):
threading.Thread.__init__(self)
self.cutter_info_dict = cutter_info_dict
self.tool_type = tool_type
self.last_electric = -1
self.N_act = 0
self.W_act = 0
self.db = DBHelper()
class DetectionPattern(threading.Thread):
def __init__(self, cutter_info_dict, tool_type):
threading.Thread.__init__(self)
self.cutter_info_dict = cutter_info_dict
self.tool_type = tool_type
self.last_electric = -1
self.N_act = 0
self.W_act = 0
self.db = DBHelper()
def run(self):
load_data = self.db.get_one(["WUp", "WLow", "DUp", "NLimit"],
cutter_load, {"ToolType": self.tool_type})
w_up = load_data[0]
w_low = load_data[1]
D_up = load_data[2]
n_limit = load_data[3]
while True:
if self.cutter_info_dict[self.tool_type]:
cutter_info_list = self.get_one_data()
print("get data :", cutter_info_list)
# 主轴停止旋转
if cutter_info_list[3] == 0:
# 刀具断刀
if self.W_act < w_low:
self.db.update(cutter_load, {"TippingAlarm": 1})
print("刀具断刀")
break
self.del_data_vessel()
print("运行正常")
break
if self.last_electric == -1:
self.last_electric = cutter_info_list[2]
continue
dP = math.fabs(cutter_info_list[2] - self.last_electric)
self.W_act += cutter_info_list[2] * sampling_period
if dP > D_up:
self.N_act += 1
#刀具磨损
if self.W_act > w_up:
self.db.update(cutter_load, {"WearWarning": 1})
print("刀具磨损")
self.del_data_vessel()
break
#刀具崩刃
if self.N_act > n_limit:
self.db.update(cutter_load, {"CuttingAlarm": 1})
print("刀具崩刃")
self.del_data_vessel()
break
# queue队列中取数据
def get_one_data(self):
return self.cutter_info_dict[self.tool_type].get()
# 检测结束时删除对应缓存抓取到的刀具数据的字典的键值对
def del_data_vessel(self):
del self.cutter_info_dict[self.tool_type]
class Compensation:
def __init__(self, tool_id):
self.tool_id = tool_id
self.db = DBHelper()
self.tool = None
self.tool_type = None
self.dimension_id = []
self.dimension_name = []
def get_compensation(self, for_now):
self.tool = self.db.get_some(['*'], config.cutter_compensation_table,
{"tool_id": 1})
self.tool_type = self.tool[0][1]
self.dimension_id = config.tools[self.tool_type - 1]["Dimension_id"]
self.dimension_name = config.tools[self.tool_type - 1]["name"]
result = []
for i in range(len(self.dimension_id)):
for j in self.dimension_name[i]:
sql="select * from {cutter}" \
" INNER JOIN {derection} " \
"ON {cutter}.component_id={derection}.component_id " \
"where {cutter}.tool_type={tool_type} " \
"AND {derection}.dimension_id='{dimension_id}' " \
"AND {derection}.name='{dimension_name}'".format(cutter=config.cutter_compensation_table,derection=config.derection_result,tool_type=self.tool_type,dimension_id=self.dimension_id[i],dimension_name=j)
result = pd.read_sql(sql, self.db.con())
sample_feature = ['machine_time']
sample_output = ['compensation_value']
LR = RidgeR(sample_feature, sample_output)
LR.train(result)
print("MSE:", LR.evaluation_model())
LR.draw()
LR.output_model_params()
return LR.predict(for_now)
def set_compensation(self, tool_id):
r = redis.Redis(host='127.0.0.1', port=6379)
r.lpush("set_compensation", tool_id)
def __del__(self):
self.db.close_db()
def __init__(self, sample_feature, sample_output, condition_dict=None):
"""
:param sample_feature: 样本特征 list
:param sample_output: 样本输出 list
:param condition_dict: 数据库查询条件 dict
"""
self.db = DBHelper()
self.sample_feature = sample_feature
self.sample_out = sample_output
self.condition_dict = condition_dict
self.field = ",".join(sample_feature + sample_output)
from config import cutter_compensation_table
#需要学习的表的name
self.table = cutter_compensation_table
# 构造不同的lambda值
Lambdas = np.logspace(-5, 2, 200)
self.ridge_cv = RidgeCV(alphas=Lambdas,
normalize=True,
scoring='neg_mean_squared_error',
cv=10)
from config import cutter_compensation_table
from DBController.DBHelper import DBHelper
import time
from compensation.CompensationFunc import Compensation
db = DBHelper()
while True:
wait_for_learn = db.get_some(["*"], cutter_compensation_table,
{"IsRead": 0})
if wait_for_learn:
for i in wait_for_learn:
db.update(cutter_compensation_table, {"IsRead": 1}, {"id": i[0]})
compensation = Compensation(i[2])
compensation_value = compensation.get_compensation(i[4])
compensation.set_compensation(compensation_value)
time.sleep(1)
class RidgeR:
def __init__(self, sample_feature, sample_output, condition_dict=None):
"""
:param sample_feature: 样本特征 list
:param sample_output: 样本输出 list
:param condition_dict: 数据库查询条件 dict
"""
self.db = DBHelper()
self.sample_feature = sample_feature
self.sample_out = sample_output
self.condition_dict = condition_dict
self.field = ",".join(sample_feature + sample_output)
from config import cutter_compensation_table
#需要学习的表的name
self.table = cutter_compensation_table
# 构造不同的lambda值
Lambdas = np.logspace(-5, 2, 200)
self.ridge_cv = RidgeCV(alphas=Lambdas,
normalize=True,
scoring='neg_mean_squared_error',
cv=10)
def train(self, result):
'''
训练模型
:param result:
:return:
'''
self.result = result
x = result[self.sample_feature]
y = result[self.sample_out]
#划分数据集
self.x_train, self.x_test, self.y_train, self.y_test = train_test_split(
x, y, test_size=0.2, random_state=0)
# #标准化
# self.transfer=StandardScaler()
# self.x_train=self.transfer.fit_transform(self.x_train)
# self.x_test=self.transfer.transform(self.x_test)
# 对交叉验证模型传入输入数据和输出数据
self.ridge_cv.fit(self.x_train, self.y_train)
# 基于最佳lambda值建模
self.estimator = Ridge(alpha=self.ridge_cv.alpha_)
self.estimator.fit(self.x_train, self.y_train)
def output_model_params(self):
'''
打印训练后模型的权重系数和偏置
:return:
'''
print("岭回归-权重系数为：", self.estimator.coef_)
print("岭回归-偏置为：", self.estimator.intercept_)
def predict(self, input_list):
"""
输入特征预测结果
:param input_list: 特征值 list
:return: 预测值
"""
input_list = pd.DataFrame(input_list)
# 标准化时使用这条
# input_list=self.transfer.transform(input_list)
result = self.estimator.predict((input_list))
return result
def draw(self):
x = np.arange(0, 2000, 7)
y = self.estimator.coef_[0][0] * x + self.estimator.intercept_[0]
plt.plot(x, y)
a = self.result[self.sample_feature]
b = self.result[self.sample_out]
plt.scatter(a, b)
plt.show()
def evaluation_model(self):
'''
模型评估
:return: 均方误差
'''
y_pred = self.estimator.predict(self.x_test)
#均方误差
MSE = metrics.mean_squared_error(self.y_test, y_pred)
return MSE
def __del__(self):
self.db.close_db()
class LearnPattern(threading.Thread):
def __init__(self,cutter_info_dict,tool_type):
threading.Thread.__init__(self)
self.cutter_info_dict=cutter_info_dict
self.tool_type=tool_type
self.W_act=0
self.max_dP=0
self.last_electric=-1
self.db=DBHelper()
self.n_limit=0
def run(self):
while(True):
if self.cutter_info_dict[self.tool_type]:
self.data=self.db.get_one(["*"],cutter_load,{"ToolType":self.tool_type})
self.cutter_info_list = self.get_one_data()
print("get data :",self.cutter_info_list)
#已学习过第一次
if self.data:
if self.learn_nlimit()==1:
self.del_data_vessel()
break
#第一次学习
else:
if self.learn_wup_wlow_dup()==1:
self.del_data_vessel()
break
#计算能耗积分和导数上限
def compute_wact_maxdp(self):
# self.cutter_info_list = self.get_one_data()
if self.last_electric == -1:
self.last_electric = self.cutter_info_list[2]
return
self.W_act += self.cutter_info_list[2] * sampling_period
dP = math.fabs(self.cutter_info_list[2] - self.last_electric)
self.last_electric = self.cutter_info_list[2]
if dP > self.max_dP:
self.max_dP = dP
#第一次学习得到能耗上限、能耗下限、导数上限
def learn_wup_wlow_dup(self):
# 主轴停止旋转
if self.cutter_info_list[3] == 0:
W_up = self.W_act * up_ratio
W_low = self.W_act * low_ratio
D_up = self.max_dP * dp_ratio
self.db.insert(cutter_load, {"ToolType": self.tool_type, "WUp": W_up, "WLow": W_low, "DUp": D_up})
return 1
self.compute_wact_maxdp()
return 0
#第二次学习通过上一次学习得出的导数上限和当前每次导数比较，得出导数超限次数
def learn_nlimit(self):
# 主轴停止旋转
if self.cutter_info_list[3] == 0:
self.db.update(cutter_load, {"Learned": 1, "Nlimit": self.n_limit})
return 1
# cutter_info_list = self.get_one_data()
if self.last_electric == -1:
self.last_electric = self.cutter_info_list[2]
return 0
dP = math.fabs(self.cutter_info_list[2] - self.last_electric)
if dP > self.data[5]:
print(dP,self.data[5])
self.n_limit += 1
return 0
#queue队列中取数据
def get_one_data(self):
return self.cutter_info_dict[self.tool_type].get()
#学习结束时删除对应缓存抓取到的刀具数据的字典的键值对
def del_data_vessel(self):
del self.cutter_info_dict[self.tool_type]
import time
from DBController.DBHelper import DBHelper
from config import cutter_detection_table, cutter_load
from detection.CutterLearn import LearnPattern
from detection.BreakageDetection import DetectionPattern
import queue
cutter_info_dict = {}
while (True):
db = DBHelper()
field_list = [
"ToolId", "ToolType", "SpindleElectric", "SpindleSpeed", "id"
]
wait_for_learn = db.get_some(field_list, cutter_detection_table,
{"IsRead": 0})
if wait_for_learn:
for i in wait_for_learn:
#刀具没有开始使用的状态（不做记录）
if i[3] == 0:
if i[1] not in cutter_info_dict:
continue
print("暂未放入queue的数据ToolType:", i[1])
if i[1] in cutter_info_dict:
print("放入queue数据：", i)
#往对应的字典键对应的列表增加数据，供线程学习或监测
cutter_info_dict[i[1]].put(list(i))
else:
#开始学习或检测
cutter_info_dict[i[1]] = queue.Queue()
is_learn_data = db.get_one(['Learned'], cutter_load,