def process_start(amount):
std = 0.0025
item_sink = []
for i in range(amount):
total_data = {}
body = []
op10_data = {}
product_key = '-' + 'W1' + 'P' + str(i)
body.append(product_key)
body_l = np.random.normal(200, std)
body_l = round(body_l, 5)
body.append(body_l)
body_w = np.random.normal(100, std)
body_w = round(body_w, 5)
body.append(body_w)
body_h = np.random.normal(50, std)
body_h = round(body_h, 5)
body.append(body_h)
op10_process_time = np.random.exponential(10)
op10_process_time = round(op10_process_time, 5)
body.append(op10_process_time)
### op 10
op10_data = machine_operate.op10(body)
op10_WIP = []
op20_data = {}
product_key = '-' + 'W2' + 'P' + str(i)
op10_WIP.append(product_key)
op10_WIP.append(op10_data['op10_l'])
op10_WIP.append(op10_data['op10_w'])
op10_WIP.append(op10_data['op10_h'])
op10_WIP.append(op10_data['op10_time_stamp'])
### op 20
op20_data = machine_operate.op20(op10_WIP)
op20_WIP = []
op30_data = {}
product_key = '-' + 'W3' + 'P' + str(i)
op20_WIP.append(product_key)
op20_WIP.append(op20_data['op20_l'])
op20_WIP.append(op20_data['op20_w'])
op20_WIP.append(op20_data['op20_h'])
op20_WIP.append(op20_data['op20_time_stamp'])
### op 30
op30_data = machine_operate.op30(op20_WIP)
op30_WIP = []
op40_data = {}
product_key = '-' + 'W4' + 'P' + str(i)
op30_WIP.append(product_key)
op30_WIP.append(op30_data['op30_l'])
op30_WIP.append(op30_data['op30_w'])
op30_WIP.append(op30_data['op30_h'])
op30_WIP.append(op30_data['op30_time_stamp'])
### op 40
op40_data = machine_operate.op40(op30_WIP)
op40_WIP = []
op50_data = {}
product_key = '-' + 'W5' + 'P' + str(i)
op40_WIP.append(product_key)
op40_WIP.append(op40_data['op40_l'])
op40_WIP.append(op40_data['op40_w'])
op40_WIP.append(op40_data['op40_h'])
op40_WIP.append(op40_data['op40_time_stamp'])
### op 50
op50_data = machine_operate.op50(op40_WIP)
op50_WIP = []
op60_data = {}
product_key = '-' + 'W6' + 'P' + str(i)
op50_WIP.append(product_key)
op50_WIP.append(op50_data['op50_l'])
op50_WIP.append(op50_data['op50_w'])
op50_WIP.append(op50_data['op50_h'])
op50_WIP.append(op50_data['op50_time_stamp'])
### op 60
op60_data = machine_operate.op60(op50_WIP)
op10_data = dict(op10_data, **op20_data)
op10_data = dict(op10_data, **op30_data)
op10_data = dict(op10_data, **op40_data)
op10_data = dict(op10_data, **op50_data)
op10_data = dict(op10_data, **op60_data)
total_data = dict(total_data, **op10_data)
item_sink.append(total_data)
result_df = pd.DataFrame(item_sink)
result_df = result_df.set_index('product_key')
return total_data
def process_start(char3):
std = 0.0025
item_sink = []
## 미리 초기 시간 값 정의
op10_timestamp = datetime.now()
op20_timestamp = datetime.now()
op30_timestamp = datetime.now()
op40_timestamp = datetime.now()
op50_timestamp = datetime.now()
op60_timestamp = datetime.now()
## 초기 셋업 타임 설정
op10_setup_time = 0
op20_setup_time = 0
op30_setup_time = 0
op40_setup_time = 0
op50_setup_time = 0
op60_setup_time = 0
for i in range(char3):
total_data = {}
op10_process_time = np.random.triangular(9, 10, 10)
op10_process_time = round(op10_process_time, 5)
op20_process_time = np.random.triangular(9, 10, 10)
op20_process_time = round(op20_process_time, 5)
op30_process_time = np.random.triangular(9, 10, 10)
op30_process_time = round(op30_process_time, 5)
op40_process_time = np.random.triangular(9, 10, 10)
op40_process_time = round(op40_process_time, 5)
op50_process_time = np.random.triangular(9, 10, 10)
op50_process_time = round(op50_process_time, 5)
op60_process_time = np.random.triangular(9, 10, 10)
op60_process_time = round(op60_process_time, 5)
body = []
op10_data = {}
product_key = '-' + 'W1' + 'P' + str(i)
body.append(product_key)
body_l = np.random.normal(200, std)
body_l = round(body_l, 5)
body.append(body_l)
body_w = np.random.normal(100, std)
body_w = round(body_w, 5)
body.append(body_w)
body_h = np.random.normal(50, std)
body_h = round(body_h, 5)
body.append(body_h)
body.append(op10_process_time) # <- 여기까지 body에 생성한 값 넣어주고 공정에 돌리기
body.append(op10_timestamp)
### op 10 시작
op10_data = machine_operate.op10(body) # <- 공정 돌리고 난 후 데이터
op10_WIP = []
op20_data = {}
product_key = '-' + 'W2' + 'P' + str(i)
op10_WIP.append(product_key)
op10_WIP.append(
op10_data['op10_l']) # <- 돌리고 난 후 데이터 모음에서 결과값 하나씩 가져오기
op10_WIP.append(op10_data['op10_w'])
op10_WIP.append(op10_data['op10_h'])
op10_WIP.append(op10_data['op10_time_stamp']) # 다음 공정 시작할 시간
op10_WIP.append(op20_process_time)
## op20 시작
## 병목인지 아닌지 판단
op10_timestamp = op10_data['op10_time_stamp'] # op10에서 끝난 시간 가져옴
op20_start_time = op10_timestamp # 기본적으로 op20 시작 시간은 op10 끝난 시간
if op20_timestamp < op10_timestamp: # 앞공정에서 더 늦게 끝남 -> 만약 대기행렬에 하나도 없으면 -> 뒷공정이 놀고있다
op20_start_time = op10_timestamp + timedelta(
seconds=op10_setup_time) # 앞공정 끝난시간이 뒷공정 시작시간 + 셋업타임
op10_WIP.append(
op20_start_time) # 재공품 정보에 시작해야할 시간 저장 / 인덱스 5번
op20_data = machine_operate.op20(
op10_WIP) # <- 대기 행렬에 아무것도 없으면 그냥 바로 받아서 실행
else: # 앞공정이 더 빨리 끝나면 -> 뒷공정은 계속 일하는 중 -> 대기행렬에 추가
op20_start_time = op20_timestamp + timedelta(
seconds=op10_setup_time) # 처리한 물품 끝나고 바로 공정 시작 + 셋업타임
op10_WIP.append(
op20_start_time) # 재공품 정보에 시작해야할 시간 저장 / 인덱스 5번
op20_data = machine_operate.op20(
op10_WIP) # <- 대기 행렬에 아무것도 없으면 그냥 바로 받아서 실행
op20_timestamp = op20_data['op20_time_stamp']
op20_WIP = []
op30_data = {}
product_key = '-' + 'W3' + 'P' + str(i) # <- 키 설정
op20_WIP.append(product_key)
op20_WIP.append(op20_data['op20_l'])
op20_WIP.append(op20_data['op20_w'])
op20_WIP.append(op20_data['op20_h'])
op20_WIP.append(op20_data['op20_time_stamp'])
op20_WIP.append(op30_process_time)
## op30 시작
## 병목인지 아닌지 판단
op20_timestamp = op20_data['op20_time_stamp'] # op10에서 끝난 시간 가져옴
op30_start_time = op20_timestamp # 기본적으로 op30 시작 시간은 op20 끝난 시간
if op30_timestamp < op20_timestamp: # 앞공정에서 더 늦게 끝남 -> 만약 대기행렬에 하나도 없으면 -> 뒷공정이 놀고있다
op30_start_time = op20_timestamp + timedelta(
seconds=op20_setup_time) # 앞공정 끝난시간이 뒷공정 시작시간 + 셋업타임
op20_WIP.append(
op30_start_time) # 재공품 정보에 시작해야할 시간 저장 / 인덱스 5번
op30_data = machine_operate.op30(
op20_WIP) # <- 시작해야하는 시간 정보 받아서 다음공정 실행
else: # 앞공정이 더 빨리 끝나면 -> 뒷공정은 계속 일하는 중 -> 대기행렬에 추가
op30_start_time = op30_timestamp + timedelta(
seconds=op20_setup_time) # 처리한 물품 끝나고 바로 공정 시작 + 셋업타임
op20_WIP.append(
op30_start_time) # 재공품 정보에 시작해야할 시간 저장 / 인덱스 5번
op30_data = machine_operate.op30(
op20_WIP) # <- 시작해야하는 시간 정보 받아서 다음공정 실행
op30_timestamp = op30_data['op30_time_stamp']
op30_WIP = []
op40_data = {}
product_key = '-' + 'W4' + 'P' + str(i)
op30_WIP.append(product_key)
op30_WIP.append(op30_data['op30_l'])
op30_WIP.append(op30_data['op30_w'])
op30_WIP.append(op30_data['op30_h'])
op30_WIP.append(op30_data['op30_time_stamp'])
op30_WIP.append(op40_process_time)
## op40 시작
## 병목인지 아닌지 판단
op30_timestamp = op30_data['op30_time_stamp'] # op10에서 끝난 시간 가져옴
op40_start_time = op30_timestamp # 기본적으로 op40 시작 시간은 op30 끝난 시간
if op40_timestamp < op30_timestamp: # 앞공정에서 더 늦게 끝남 -> 만약 대기행렬에 하나도 없으면 -> 뒷공정이 놀고있다
op40_start_time = op30_timestamp + timedelta(
seconds=op30_setup_time) # 앞공정 끝난시간이 뒷공정 시작시간 + 셋업타임
op30_WIP.append(
op40_start_time) # 재공품 정보에 시작해야할 시간 저장 / 인덱스 5번
op40_data = machine_operate.op40(
op30_WIP) # <- 시작해야하는 시간 정보 받아서 다음공정 실행
else: # 앞공정이 더 빨리 끝나면 -> 뒷공정은 계속 일하는 중 -> 대기행렬에 추가
op40_start_time = op40_timestamp + timedelta(
seconds=op30_setup_time) # 처리한 물품 끝나고 바로 공정 시작 + 셋업타임
op30_WIP.append(
op40_start_time) # 재공품 정보에 시작해야할 시간 저장 / 인덱스 5번
op40_data = machine_operate.op40(
op30_WIP) # <- 시작해야하는 시간 정보 받아서 다음공정 실행
op40_timestamp = op40_data['op40_time_stamp']
op40_WIP = []
op50_data = {}
product_key = '-' + 'W5' + 'P' + str(i)
op40_WIP.append(product_key)
op40_WIP.append(op40_data['op40_l'])
op40_WIP.append(op40_data['op40_w'])
op40_WIP.append(op40_data['op40_h'])
op40_WIP.append(op40_data['op40_time_stamp'])
op40_WIP.append(op50_process_time)
## op 50 시작
## 병목인지 아닌지 판단
op40_timestamp = op40_data['op40_time_stamp'] # op10에서 끝난 시간 가져옴
op50_start_time = op40_timestamp # 기본적으로 op50 시작 시간은 op40 끝난 시간
if op50_timestamp < op40_timestamp: # 앞공정에서 더 늦게 끝남 -> 만약 대기행렬에 하나도 없으면 -> 뒷공정이 놀고있다
op50_start_time = op40_timestamp + timedelta(
seconds=op40_setup_time) # 앞공정 끝난시간이 뒷공정 시작시간 + 셋업타임
op40_WIP.append(
op50_start_time) # 재공품 정보에 시작해야할 시간 저장 / 인덱스 5번
op50_data = machine_operate.op50(
op40_WIP) # <- 시작해야하는 시간 정보 받아서 다음공정 실행
else: # 앞공정이 더 빨리 끝나면 -> 뒷공정은 계속 일하는 중 -> 대기행렬에 추가
op50_start_time = op50_timestamp + timedelta(
seconds=op40_setup_time) # 처리한 물품 끝나고 바로 공정 시작 + 셋업타임
op40_WIP.append(
op50_start_time) # 재공품 정보에 시작해야할 시간 저장 / 인덱스 5번
op50_data = machine_operate.op50(
op40_WIP) # <- 시작해야하는 시간 정보 받아서 다음공정 실행
op50_timestamp = op50_data['op50_time_stamp']
op50_WIP = []
op60_data = {}
product_key = '-' + 'W6' + 'P' + str(i)
op50_WIP.append(product_key)
op50_WIP.append(op50_data['op50_l'])
op50_WIP.append(op50_data['op50_w'])
op50_WIP.append(op50_data['op50_h'])
op50_WIP.append(op50_data['op50_time_stamp'])
op50_WIP.append(op60_process_time)
## op60 시작
## 병목인지 아닌지 판단
op50_timestamp = op50_data['op50_time_stamp'] # op10에서 끝난 시간 가져옴
op60_start_time = op50_timestamp # 기본적으로 op60 시작 시간은 op50 끝난 시간
if op60_timestamp < op50_timestamp: # 앞공정에서 더 늦게 끝남 -> 만약 대기행렬에 하나도 없으면 -> 뒷공정이 놀고있다
op60_start_time = op50_timestamp + timedelta(
seconds=op50_setup_time) # 앞공정 끝난시간이 뒷공정 시작시간 + 셋업타임
op50_WIP.append(
op60_start_time) # 재공품 정보에 시작해야할 시간 저장 / 인덱스 5번
op60_data = machine_operate.op60(
op50_WIP) # <- 시작해야하는 시간 정보 받아서 다음공정 실행
else: # 앞공정이 더 빨리 끝나면 -> 뒷공정은 계속 일하는 중 -> 대기행렬에 추가
op60_start_time = op60_timestamp + timedelta(
seconds=op50_setup_time) # 처리한 물품 끝나고 바로 공정 시작 + 셋업타임
op50_WIP.append(
op60_start_time) # 재공품 정보에 시작해야할 시간 저장 / 인덱스 5번
op60_data = machine_operate.op60(
op50_WIP) # <- 시작해야하는 시간 정보 받아서 다음공정 실행
op60_timestamp = op60_data['op60_time_stamp']
op10_data = dict(op10_data, **op20_data)
op10_data = dict(op10_data, **op30_data)
op10_data = dict(op10_data, **op40_data)
op10_data = dict(op10_data, **op50_data)
op10_data = dict(op10_data, **op60_data)
total_data = dict(total_data, **op10_data)
item_sink.append(total_data)
result_df = pd.DataFrame(item_sink)
result_df = result_df.set_index('product_key')
return total_data
def process_start(amount):
std = 0.0025 # 표준편차 100만개 중에 12개 불량
num = MySQL_query.key_for_count(1) # 키 번호를 매기기 위한 값을 DB에서 가져옴 op10 키
if num == []: # 아무것도 없으면 -> 생산이 안됐음
n = 10001 # 처음 10001 번 품목으로 키값을 찍어라. n은 P10001 <- 요 숫자
else: # 하나라도 있으면
n = num[0][
'product_key'] # ['product_key' : 'xxxx'] n은 키 값 -> str 형식
bar_count = 0 # 키 파싱하기 위한
for index in range(len(n)):
if n[index] == '-':
bar_count = bar_count + 1
if bar_count == 3:
break
n = int(n[index + 4:]) + 1 # 지금까지 만들어진 품목 번호 + 1을 시작값으로 만들겠다.
total_test_data = [] # 예측할 test 데이터들을 뽑기 위한 모음
stop_button = None # 정지 버튼 True 되면 공정 스탑 하고 정지하거나 리셋
##### 전체적인 진행: body 생성 -> op10 실행 -> DB 저장 -> 저장한 데이터 가져오기 -> op10_data 변수 저장 -> 다음 공정 실행
body_P0 = [] # 공정에 넣을 body 데이터 리스트 틀 -> Machine에 넣을 예정
product_key_W1P0 = '-' + 'W1' + 'P' + str(
n) # 첫번째 제품 primary_key 생성 -> machine에서 시간 추가할 예정
body_P0.append(product_key_W1P0)
body_l_P0 = np.random.normal(200, std) # body 치수 데이터 생성
body_l_P0 = round(body_l_P0, 5) # 소수점 5째 자리까지 만들어줘
body_P0.append(body_l_P0) # 리스트에 담기
body_w_P0 = np.random.normal(100, std)
body_w_P0 = round(body_w_P0, 5)
body_P0.append(body_w_P0)
body_h_P0 = np.random.normal(50, std)
body_h_P0 = round(body_h_P0, 5)
body_P0.append(body_h_P0)
op10_process_time_P0 = np.random.triangular(
9, 10, 10) # process_time 생성 (최소, 최대, 최빈)
op10_process_time_P0 = round(op10_process_time_P0, 5)
body_P0.append(op10_process_time_P0)
body_P0.append(
datetime.now() +
timedelta(hours=9)) # 첫번째 제품은 현재시간부터 시작한다고 가정, 한국시간에 맞추기 위해 9시간 추가
print('한개 생산 중')
time.sleep(10) # 10초 텀 실제 시간으로 텀을 주도록 만듬
# op10 공정 실행 (W1P0)
op10_data_P0 = machine_operate.op10(body_P0)
product_key_W1P0 = op10_data_P0['product_key']
##### 여기에 웹페이지로 쏴주는 기능 추가 #####
#################################### W1P0 생산 및 DB 저장 완료 #####################################
# 다음 공정에 넣기 위한 데이터 가져와서 넣기
op10_data_P0_from_DB = MySQL_query.get_quality_data_for_process(
product_key_W1P0)
op10_data_list_P0 = [] # P0 재공품 다음공정으로 넣어줄 데이터 저장할 리스트
op10_l_P0 = op10_data_P0_from_DB[0][
'product_size_l'] # 재공품 치수 데이터 가져오기
op10_w_P0 = op10_data_P0_from_DB[0]['product_size_w']
op10_h_P0 = op10_data_P0_from_DB[0]['product_size_h']
op20_process_time_P0 = np.random.triangular(
9, 10, 10) # 다음 공정에 넣어줄 process_time 새로 생성
op20_process_time_P0 = round(op20_process_time_P0, 5)
op20_product_key_P0 = '-' + 'W2' + 'P' + str(n) # 제품 키 생성
op20_start_time_P0 = datetime.now() + timedelta(hours=9)
op10_data_list_P0.append(op20_product_key_P0) # 2번째 제품 키 - 인덱스 0번
op10_data_list_P0.append(op10_l_P0) # 1번 - 길이
op10_data_list_P0.append(op10_w_P0) # 2번 - 너비
op10_data_list_P0.append(op10_h_P0) # 3번 - 높이
op10_data_list_P0.append(
op20_process_time_P0) # 4번 - 다음 공정 작업할 process_time
op10_data_list_P0.append(
op20_start_time_P0
) # 재공품 정보에 시작해야할 시간 저장 / 인덱스 5번 // # op20 넣기위한 리스트를 만들어주고 있음.
body_P1 = [] # P1 제품에 대한 body 값 저장할 리스트
product_key_W1P1 = '-' + 'W1' + 'P' + str(
n + 1) # 첫번째 제품 primary_key 생성 -> machine에서 시간 추가할 예정
body_P1.append(product_key_W1P1)
body_l_P1 = np.random.normal(200, std) # body 치수 데이터 생성
body_l_P1 = round(body_l_P1, 5)
body_P1.append(body_l_P1)
body_w_P1 = np.random.normal(100, std)
body_w_P1 = round(body_w_P1, 5)
body_P1.append(body_w_P1)
body_h_P1 = np.random.normal(50, std)
body_h_P1 = round(body_h_P1, 5)
body_P1.append(body_h_P1)
op10_process_time_P1 = np.random.triangular(9, 10,
10) # process_time 생성
op10_process_time_P1 = round(op10_process_time_P1, 5)
body_P1.append(op10_process_time_P1)
body_P1.append(datetime.now() + timedelta(hours=9))
print('두개 생산 중')
time.sleep(10) # 10초 텀
# op20 공정 실행 (W2P0)
op20_data_P0 = machine_operate.op20(
op10_data_list_P0) # <- 앞공정 재공품 받아서 실행 // 리스트를 넣어줌
product_key_W2P0 = op20_data_P0['product_key']
#################################### W2P0 생산 및 DB 저장 완료 #####################################
# op10 공정 실행 (W1P1)
op10_data_P1 = machine_operate.op10(body_P1)
product_key_W1P1 = op10_data_P1['product_key']
#################################### W1P1 생산 및 DB 저장 완료 #####################################
# 다음 공정에 넣기 위한 데이터 가져오기
op20_data_P0_from_DB = MySQL_query.get_quality_data_for_process(
product_key_W2P0)
# 다음 공정에 넣기 위한 데이터 가져오기
op10_data_P1_from_DB = MySQL_query.get_quality_data_for_process(
product_key_W1P1)
# op20 P0 생산 끝낸 데이터를 다음 공정에 넣을 변수에 저장하기
op20_data_list_P0 = []
product_key_W3P0 = '-' + 'W3' + 'P' + str(n) # 제품 키 생성
op20_l_P0 = op20_data_P0_from_DB[0]['product_size_l']
op20_w_P0 = op20_data_P0_from_DB[0]['product_size_w']
op20_h_P0 = op20_data_P0_from_DB[0]['product_size_h']
op20_timestamp_P0 = op20_data_P0_from_DB[0][
'product_test_timestamp'] # op20 끝난시간
op30_process_time_P0 = np.random.triangular(
9, 10, 10) # 다음 공정에 넣어줄 process_time
op30_process_time_P0 = round(op30_process_time_P0, 5)
op30_start_time_P0 = datetime.now() + timedelta(hours=9)
op20_data_list_P0.append(product_key_W3P0)
op20_data_list_P0.append(op20_l_P0)
op20_data_list_P0.append(op20_w_P0)
op20_data_list_P0.append(op20_h_P0)
op20_data_list_P0.append(op30_process_time_P0)
op20_data_list_P0.append(op30_start_time_P0)
# op10 P1 생산 끝낸 데이터를 다음 공정에 넣을 변수에 저장하기
op10_data_list_P1 = []
product_key_W2P1 = '-' + 'W2' + 'P' + str(n + 1) # 제품 키 생성
op10_l_P1 = op10_data_P1_from_DB[0]['product_size_l']
op10_w_P1 = op10_data_P1_from_DB[0]['product_size_w']
op10_h_P1 = op10_data_P1_from_DB[0]['product_size_h']
op10_timestamp_P1 = op10_data_P1_from_DB[0][
'product_test_timestamp'] # op20 끝난시간
op20_process_time_P1 = np.random.triangular(
9, 10, 10) # 다음 공정에 넣어줄 process_time
op20_process_time_P1 = round(op20_process_time_P1, 5)
op20_start_time_P1 = datetime.now() + timedelta(hours=9)
op10_data_list_P1.append(
product_key_W2P1) # 재공품 데이터 -> 다음 공정에 투입 (P1제품)
op10_data_list_P1.append(op10_l_P1)
op10_data_list_P1.append(op10_w_P1)
op10_data_list_P1.append(op10_h_P1)
op10_data_list_P1.append(op20_process_time_P1)
op10_data_list_P1.append(op20_start_time_P1)
body_P2 = [] # P1 제품에 대한 body 값 저장할 리스트
product_key_W1P2 = '-' + 'W1' + 'P' + str(
n + 2) # 첫번째 제품 primary_key 생성 -> machine에서 시간 추가할 예정
body_P2.append(product_key_W1P2)
body_l_P2 = np.random.normal(200, std) # body 치수 데이터 생성
body_l_P2 = round(body_l_P2, 5)
body_P2.append(body_l_P2)
body_w_P2 = np.random.normal(100, std)
body_w_P2 = round(body_w_P2, 5)
body_P2.append(body_w_P2)
body_h_P2 = np.random.normal(50, std)
body_h_P2 = round(body_h_P2, 5)
body_P2.append(body_h_P2)
op10_process_time_P2 = np.random.triangular(9, 10,
10) # process_time 생성
op10_process_time_P2 = round(op10_process_time_P2, 5)
body_P2.append(op10_process_time_P2)
body_P2.append(datetime.now() +
timedelta(hours=9)) # 세번째 제품은 P1 끝난시간부터 시작
# op30, 20, 10 시작
print('세개 생산 중')
time.sleep(10)
# op30 공정 실행 (W3P0)
op30_data_P0 = machine_operate.op30(
op20_data_list_P0) # <- 앞공정 재공품 받아서 실행
pred_P0 = Predict.predict_quality(op10_data_P0, op20_data_P0,
op30_data_P0)
print("P0 예측값 : " + str(pred_P0))
MySQL_query.insert_product_prediction(op30_data_P0, op20_data_P0,
op10_data_P0, pred_P0)
product_key_W3P0 = op30_data_P0['product_key']
#################################### W3P0 생산 및 DB 저장 완료 #####################################
# op20 공정 실행 (W2P1)
op20_data_P1 = machine_operate.op20(
op10_data_list_P1) # <- 앞공정 재공품 받아서 실행
product_key_W2P1 = op20_data_P1['product_key']
#################################### W2P1 생산 및 DB 저장 완료 #####################################
# op10 공정 실행 (W1P2)
op10_data_P2 = machine_operate.op10(body_P2)
product_key_W1P2 = op10_data_P2['product_key']
#################################### W1P2 생산 및 DB 저장 완료 #####################################
# 다음 공정에 넣기 위한 데이터 가져오기
op30_data_P0_from_DB = MySQL_query.get_quality_data_for_process(
product_key_W3P0)
# 다음 공정에 넣기 위한 데이터 가져오기
op20_data_P1_from_DB = MySQL_query.get_quality_data_for_process(
product_key_W2P1)
# 다음 공정에 넣기 위한 데이터 가져오기
op10_data_P2_from_DB = MySQL_query.get_quality_data_for_process(
product_key_W1P2)
# op30 P0 생산 끝낸 데이터를 다음 공정에 넣을 변수에 저장하기
op30_data_list_P0 = []
product_key_W4P0 = '-' + 'W4' + 'P' + str(n) # 제품 키 생성
op30_l_P0 = op30_data_P0_from_DB[0]['product_size_l']
op30_w_P0 = op30_data_P0_from_DB[0]['product_size_w']
op30_h_P0 = op30_data_P0_from_DB[0]['product_size_h']
op30_timestamp_P0 = op30_data_P0_from_DB[0][
'product_test_timestamp'] # op20 끝난시간
op40_process_time_P0 = np.random.triangular(
9, 10, 10) # 다음 공정에 넣어줄 process_time
op40_process_time_P0 = round(op40_process_time_P0, 5)
op40_start_time_P0 = datetime.now() + timedelta(hours=9)
op30_data_list_P0.append(product_key_W4P0)
op30_data_list_P0.append(op30_l_P0)
op30_data_list_P0.append(op30_w_P0)
op30_data_list_P0.append(op30_h_P0)
op30_data_list_P0.append(op40_process_time_P0)
op30_data_list_P0.append(op40_start_time_P0)
# op20 P1 생산 끝낸 데이터를 다음 공정에 넣을 변수에 저장하기
op20_data_list_P1 = []
product_key_W3P1 = '-' + 'W3' + 'P' + str(n + 1) # 제품 키 생성
op20_l_P1 = op20_data_P1_from_DB[0]['product_size_l']
op20_w_P1 = op20_data_P1_from_DB[0]['product_size_w']
op20_h_P1 = op20_data_P1_from_DB[0]['product_size_h']
op30_process_time_P1 = np.random.triangular(
9, 10, 10) # 다음 공정에 넣어줄 process_time
op30_process_time_P1 = round(op30_process_time_P1, 5)
op30_start_time_P1 = datetime.now() + timedelta(hours=9)
op20_data_list_P1.append(product_key_W3P1)
op20_data_list_P1.append(op20_l_P1)
op20_data_list_P1.append(op20_w_P1)
op20_data_list_P1.append(op20_h_P1)
op20_data_list_P1.append(op30_process_time_P1)
op20_data_list_P1.append(op30_start_time_P1)
# op10 P2 생산 끝낸 데이터를 다음 공정에 넣을 변수에 저장하기
op10_data_list_P2 = []
product_key_W2P2 = '-' + 'W2' + 'P' + str(n + 2) # 제품 키 생성
op10_l_P2 = op10_data_P2_from_DB[0]['product_size_l']
op10_w_P2 = op10_data_P2_from_DB[0]['product_size_w']
op10_h_P2 = op10_data_P2_from_DB[0]['product_size_h']
op20_process_time_P2 = np.random.triangular(
9, 10, 10) # 다음 공정에 넣어줄 process_time
op20_process_time_P2 = round(op20_process_time_P2, 5)
op20_start_time_P2 = datetime.now() + timedelta(hours=9)
op10_data_list_P2.append(product_key_W2P2)
op10_data_list_P2.append(op10_l_P2)
op10_data_list_P2.append(op10_w_P2)
op10_data_list_P2.append(op10_h_P2)
op10_data_list_P2.append(op20_process_time_P2)
op10_data_list_P2.append(op20_start_time_P2)
body_P3 = [] # P3 제품에 대한 body 값 저장할 리스트
product_key_W1P3 = '-' + 'W1' + 'P' + str(
n + 3) # 첫번째 제품 primary_key 생성 -> machine에서 시간 추가할 예정
body_P3.append(product_key_W1P3)
body_l_P2 = np.random.normal(200, std) # body 치수 데이터 생성
body_l_P2 = round(body_l_P2, 5)
body_P3.append(body_l_P2)
body_w_P2 = np.random.normal(100, std)
body_w_P2 = round(body_w_P2, 5)
body_P3.append(body_w_P2)
body_h_P2 = np.random.normal(50, std)
body_h_P2 = round(body_h_P2, 5)
body_P3.append(body_h_P2)
op10_process_time_P2 = np.random.triangular(9, 10,
10) # process_time 생성
op10_process_time_P2 = round(op10_process_time_P2, 5)
body_P3.append(op10_process_time_P2)
body_P3.append(datetime.now() + timedelta(hours=9))
print('네개 생산 중')
time.sleep(10)
# op40 공정 실행 (W4P0)
op40_data_P0 = machine_operate.op40(
op30_data_list_P0) # <- 앞공정 재공품 받아서 실행
product_key_W4P0 = op40_data_P0['product_key']
#################################### W4P0 생산 및 DB 저장 완료 #####################################
# op30 공정 실행 (W3P1)
op30_data_P1 = machine_operate.op30(
op20_data_list_P1) # <- 앞공정 재공품 받아서 실행
pred_P1 = Predict.predict_quality(op10_data_P1, op20_data_P1,
op30_data_P1)
print("P1 예측값 : " + str(pred_P1))
MySQL_query.insert_product_prediction(op30_data_P1, op20_data_P1,
op10_data_P1, pred_P1)
product_key_W3P1 = op30_data_P1['product_key']
#################################### W3P1 생산 및 DB 저장 완료 #####################################
# op20 공정 실행 (W2P2)
op20_data_P2 = machine_operate.op20(op10_data_list_P2)
product_key_W2P2 = op20_data_P2['product_key']
#################################### W2P2 생산 및 DB 저장 완료 #####################################
# op10 공정 실행 (W1P3)
op10_data_P3 = machine_operate.op10(body_P3)
product_key_W1P3 = op10_data_P3['product_key']
total_test_data.append(op10_data_P3)
#################################### W1P3 생산 및 DB 저장 완료 #####################################
# 다음 공정에 넣기 위한 데이터 가져오기
op40_data_P0_from_DB = MySQL_query.get_quality_data_for_process(
product_key_W4P0)
# 다음 공정에 넣기 위한 데이터 가져오기
op30_data_P1_from_DB = MySQL_query.get_quality_data_for_process(
product_key_W3P1)
# 다음 공정에 넣기 위한 데이터 가져오기
op20_data_P2_from_DB = MySQL_query.get_quality_data_for_process(
product_key_W2P2)
# 다음 공정에 넣기 위한 데이터 가져오기
op10_data_P3_from_DB = MySQL_query.get_quality_data_for_process(
product_key_W1P3)
# op40 P0 생산 끝낸 데이터를 다음 공정에 넣을 변수에 저장하기
op40_data_list_P0 = []
product_key_W5P0 = '-' + 'W5' + 'P' + str(n) # 제품 키 생성
op40_l_P0 = op40_data_P0_from_DB[0]['product_size_l']
op40_w_P0 = op40_data_P0_from_DB[0]['product_size_w']
op40_h_P0 = op40_data_P0_from_DB[0]['product_size_h']
op40_timestamp_P0 = op40_data_P0_from_DB[0][
'product_test_timestamp'] # op20 끝난시간
op50_process_time_P0 = np.random.triangular(
9, 10, 10) # 다음 공정에 넣어줄 process_time
op50_process_time_P0 = round(op50_process_time_P0, 5)
op50_start_time_P0 = datetime.now() + timedelta(hours=9)
op40_data_list_P0.append(product_key_W5P0)
op40_data_list_P0.append(op40_l_P0)
op40_data_list_P0.append(op40_w_P0)
op40_data_list_P0.append(op40_h_P0)
op40_data_list_P0.append(op50_process_time_P0)
op40_data_list_P0.append(op50_start_time_P0)
# op30 P1 생산 끝낸 데이터를 다음 공정에 넣을 변수에 저장하기
op30_data_list_P1 = []
product_key_W4P1 = '-' + 'W4' + 'P' + str(n + 1) # 제품 키 생성
op30_l_P1 = op30_data_P1_from_DB[0]['product_size_l']
op30_w_P1 = op30_data_P1_from_DB[0]['product_size_w']
op30_h_P1 = op30_data_P1_from_DB[0]['product_size_h']
op30_timestamp_P1 = op30_data_P1_from_DB[0][
'product_test_timestamp'] # op30 끝난시간
op40_process_time_P1 = np.random.triangular(
9, 10, 10) # 다음 공정에 넣어줄 process_time
op40_process_time_P1 = round(op40_process_time_P1, 5)
op40_start_time_P1 = datetime.now() + timedelta(hours=9)
op30_data_list_P1.append(product_key_W4P1)
op30_data_list_P1.append(op30_l_P1)
op30_data_list_P1.append(op30_w_P1)
op30_data_list_P1.append(op30_h_P1)
op30_data_list_P1.append(op40_process_time_P1)
op30_data_list_P1.append(op40_start_time_P1)
# op20 P2 생산 끝낸 데이터를 다음 공정에 넣을 변수에 저장하기
op20_data_list_P2 = []
product_key_W3P2 = '-' + 'W3' + 'P' + str(n + 2) # 제품 키 생성
op20_l_P2 = op20_data_P2_from_DB[0]['product_size_l']
op20_w_P2 = op20_data_P2_from_DB[0]['product_size_w']
op20_h_P2 = op20_data_P2_from_DB[0]['product_size_h']
op30_process_time_P2 = np.random.triangular(
9, 10, 10) # 다음 공정에 넣어줄 process_time
op30_process_time_P2 = round(op30_process_time_P2, 5)
op30_start_time_P2 = datetime.now() + timedelta(hours=9)
op20_data_list_P2.append(product_key_W3P2)
op20_data_list_P2.append(op20_l_P2)
op20_data_list_P2.append(op20_w_P2)
op20_data_list_P2.append(op20_h_P2)
op20_data_list_P2.append(op30_process_time_P2)
op20_data_list_P2.append(op30_start_time_P2)
# op10 P1 생산 끝낸 데이터를 다음 공정에 넣을 변수에 저장하기
op10_data_list_P3 = []
product_key_W2P3 = '-' + 'W2' + 'P' + str(n + 3) # 제품 키 생성
op10_l_P3 = op10_data_P3_from_DB[0]['product_size_l']
op10_w_P3 = op10_data_P3_from_DB[0]['product_size_w']
op10_h_P3 = op10_data_P3_from_DB[0]['product_size_h']
op20_process_time_P3 = np.random.triangular(
9, 10, 10) # 다음 공정에 넣어줄 process_time
op20_process_time_P3 = round(op20_process_time_P3, 5)
op20_start_time_P3 = datetime.now() + timedelta(hours=9)
op10_data_list_P3.append(product_key_W2P3)
op10_data_list_P3.append(op10_l_P3)
op10_data_list_P3.append(op10_w_P3)
op10_data_list_P3.append(op10_h_P3)
op10_data_list_P3.append(op20_process_time_P3)
op10_data_list_P3.append(op20_start_time_P3)
body_P4 = [] # P1 제품에 대한 body 값 저장할 리스트
product_key_W1P4 = '-' + 'W1' + 'P' + str(
n + 4) # 첫번째 제품 primary_key 생성 -> machine에서 시간 추가할 예정
body_P4.append(product_key_W1P4)
body_l_P3 = np.random.normal(200, std) # body 치수 데이터 생성
body_l_P3 = round(body_l_P3, 5)
body_P4.append(body_l_P3)
body_w_P3 = np.random.normal(100, std)
body_w_P3 = round(body_w_P3, 5)
body_P4.append(body_w_P3)
body_h_P3 = np.random.normal(50, std)
body_h_P3 = round(body_h_P3, 5)
body_P4.append(body_h_P3)
op10_process_time_P3 = np.random.triangular(9, 10,
10) # process_time 생성
op10_process_time_P3 = round(op10_process_time_P3, 5)
body_P4.append(op10_process_time_P3)
body_P4.append(datetime.now() +
timedelta(hours=9)) # 다섯 번째 제품은 P3 끝난시간부터 시작
print('다섯개 생산 중')
time.sleep(10)
# op50 공정 실행 (W5P0)
op50_data_P0 = machine_operate.op50(
op40_data_list_P0) # <- 앞공정 재공품 받아서 실행
product_key_W5P0 = op50_data_P0['product_key']
#################################### W5P0 생산 및 DB 저장 완료 #####################################
# op40 공정 실행 (W4P1)
op40_data_P1 = machine_operate.op40(
op30_data_list_P1) # <- 앞공정 재공품 받아서 실행
product_key_W4P1 = op40_data_P1['product_key']
#################################### W4P1 생산 및 DB 저장 완료 #####################################
# op30 공정 실행 (W3P2)
op30_data_P2 = machine_operate.op30(
op20_data_list_P2) # <- 앞공정 재공품 받아서 실행
pred_P2 = Predict.predict_quality(op10_data_P2, op20_data_P2,
op30_data_P2)
print("P2 예측값 : " + str(pred_P2))
MySQL_query.insert_product_prediction(op30_data_P2, op20_data_P2,
op10_data_P2, pred_P2)
product_key_W3P2 = op30_data_P2['product_key']
#################################### W3P2 생산 및 DB 저장 완료 #####################################
# op20 공정 실행 (W2P3)
op20_data_P3 = machine_operate.op20(op10_data_list_P3)
product_key_W2P3 = op20_data_P3['product_key']
total_test_data.append(op20_data_P3)
#################################### W2P3 생산 및 DB 저장 완료 #####################################
# op10 공정 실행 (W1P4)
op10_data_P4 = machine_operate.op10(body_P4)
product_key_W1P4 = op10_data_P4['product_key']
total_test_data.append(op10_data_P4)
#################################### W1P4 생산 및 DB 저장 완료 #####################################
# 여기서부터 6개씩 반복
print('for문 진입')
for i in range(n + 5, 100000): # 6번째 제품부터 반복 시작
op10_process_time = np.random.triangular(9, 10, 10)
op10_process_time = round(op10_process_time, 5)
op20_process_time = np.random.triangular(9, 10, 10)
op20_process_time = round(op20_process_time, 5)
op30_process_time = np.random.triangular(9, 10, 10)
op30_process_time = round(op30_process_time, 5)
op40_process_time = np.random.triangular(9, 10, 10)
op40_process_time = round(op40_process_time, 5)
op50_process_time = np.random.triangular(9, 10, 10)
op50_process_time = round(op50_process_time, 5)
op60_process_time = np.random.triangular(9, 10, 10)
op60_process_time = round(op60_process_time, 5)
if i == n + 5: # 딱 처음 for 문 진입했을 때만 실행
op50_data_P0_from_DB = MySQL_query.get_quality_data_for_process(
product_key_W5P0) # 전 공정에서 끝나고 결과 데이터
op50_WIP = [] # op60에 넣기 위한 리스트
product_key_W6P0 = '-' + 'W6' + 'P' + str(i - 5) # key값 부여
op50_l_P0 = op50_data_P0_from_DB[0][
'product_size_l'] # 데이터 나눠서 변수에 저장
op50_w_P0 = op50_data_P0_from_DB[0]['product_size_w']
op50_h_P0 = op50_data_P0_from_DB[0]['product_size_h']
op60_start_time = op50_data_P0_from_DB[0][
'product_test_timestamp']
op50_WIP.append(product_key_W6P0) # 변수에 저장한거 하나씩 리스테에 저장
op50_WIP.append(op50_l_P0)
op50_WIP.append(op50_w_P0)
op50_WIP.append(op50_h_P0)
op50_WIP.append(op60_process_time)
op50_WIP.append(op60_start_time)
op40_data_P1_from_DB = MySQL_query.get_quality_data_for_process(
product_key_W4P1)
op40_WIP = []
product_key_W5P1 = '-' + 'W5' + 'P' + str(i - 4)
op40_l_P1 = op40_data_P1_from_DB[0]['product_size_l']
op40_w_P1 = op40_data_P1_from_DB[0]['product_size_w']
op40_h_P1 = op40_data_P1_from_DB[0]['product_size_h']
op50_start_time = op40_data_P1_from_DB[0][
'product_test_timestamp']
op40_WIP.append(product_key_W5P1)
op40_WIP.append(op40_l_P1)
op40_WIP.append(op40_w_P1)
op40_WIP.append(op40_h_P1)
op40_WIP.append(op50_process_time)
op40_WIP.append(op50_start_time)
op30_data_P2_from_DB = MySQL_query.get_quality_data_for_process(
product_key_W3P2)
op30_WIP = []
product_key_W4P2 = '-' + 'W4' + 'P' + str(i - 3)
op30_l_P2 = op30_data_P2_from_DB[0]['product_size_l']
op30_w_P2 = op30_data_P2_from_DB[0]['product_size_w']
op30_h_P2 = op30_data_P2_from_DB[0]['product_size_h']
op40_start_time = op30_data_P2_from_DB[0][
'product_test_timestamp']
op30_WIP.append(product_key_W4P2)
op30_WIP.append(op30_l_P2)
op30_WIP.append(op30_w_P2)
op30_WIP.append(op30_h_P2)
op30_WIP.append(op40_process_time)
op30_WIP.append(op40_start_time)
op20_data_P3_from_DB = MySQL_query.get_quality_data_for_process(
product_key_W2P3)
op20_WIP = []
product_key_W3P3 = '-' + 'W3' + 'P' + str(i - 2)
op20_l_P3 = op20_data_P3_from_DB[0]['product_size_l']
op20_w_P3 = op20_data_P3_from_DB[0]['product_size_w']
op20_h_P3 = op20_data_P3_from_DB[0]['product_size_h']
op30_start_time = op20_data_P3_from_DB[0][
'product_test_timestamp']
op20_WIP.append(product_key_W3P3)
op20_WIP.append(op20_l_P3)
op20_WIP.append(op20_w_P3)
op20_WIP.append(op20_h_P3)
op20_WIP.append(op30_process_time)
op20_WIP.append(op30_start_time)
op10_data_P4_from_DB = MySQL_query.get_quality_data_for_process(
product_key_W1P4)
op10_WIP = []
product_key_W2P4 = '-' + 'W2' + 'P' + str(i - 1)
op10_l_P4 = op10_data_P4_from_DB[0]['product_size_l']
op10_w_P4 = op10_data_P4_from_DB[0]['product_size_w']
op10_h_P4 = op10_data_P4_from_DB[0]['product_size_h']
op20_start_time = op10_data_P4_from_DB[0][
'product_test_timestamp']
op10_WIP.append(product_key_W2P4)
op10_WIP.append(op10_l_P4)
op10_WIP.append(op10_w_P4)
op10_WIP.append(op10_h_P4)
op10_WIP.append(op20_process_time)
op10_WIP.append(op20_start_time)
op10_time_stamp = datetime.now() + timedelta(hours=9)
else: # 한바퀴 돌고 난 다음
op50_WIP = []
product_key_W6 = '-' + 'W6' + 'P' + str(i - 5)
op50_l = op50_data['op50_l']
op50_w = op50_data['op50_w']
op50_h = op50_data['op50_h']
op50_WIP.append(product_key_W6)
op50_WIP.append(op50_l)
op50_WIP.append(op50_w)
op50_WIP.append(op50_h)
op50_WIP.append(op60_process_time)
op50_WIP.append(datetime.now() + timedelta(hours=9))
op40_WIP = []
product_key_W5 = '-' + 'W5' + 'P' + str(i - 4)
op40_l = op40_data['op40_l']
op40_w = op40_data['op40_w']
op40_h = op40_data['op40_h']
op40_WIP.append(product_key_W5)
op40_WIP.append(op40_l)
op40_WIP.append(op40_w)
op40_WIP.append(op40_h)
op40_WIP.append(op50_process_time)
op40_WIP.append(datetime.now() + timedelta(hours=9))
op30_WIP = []
product_key_W4 = '-' + 'W4' + 'P' + str(i - 3)
op30_l = op30_data['op30_l']
op30_w = op30_data['op30_w']
op30_h = op30_data['op30_h']
op30_WIP.append(product_key_W4)
op30_WIP.append(op30_l)
op30_WIP.append(op30_w)
op30_WIP.append(op30_h)
op30_WIP.append(op40_process_time)
op30_WIP.append(datetime.now() + timedelta(hours=9))
op20_WIP = []
product_key_W3 = '-' + 'W3' + 'P' + str(i - 2)
op20_l = op20_data['op20_l']
op20_w = op20_data['op20_w']
op20_h = op20_data['op20_h']
op20_WIP.append(product_key_W3)
op20_WIP.append(op20_l)
op20_WIP.append(op20_w)
op20_WIP.append(op20_h)
op20_WIP.append(op30_process_time)
op20_WIP.append(datetime.now() + timedelta(hours=9))
op10_WIP = []
product_key_W2 = '-' + 'W2' + 'P' + str(i - 1)
op10_l = op10_data['op10_l']
op10_w = op10_data['op10_w']
op10_h = op10_data['op10_h']
op10_WIP.append(product_key_W2)
op10_WIP.append(op10_l)
op10_WIP.append(op10_w)
op10_WIP.append(op10_h)
op10_WIP.append(op20_process_time)
op10_WIP.append(datetime.now() + timedelta(hours=9))
# 새 제품 생산
body = []
product_key_W1 = '-' + 'W1' + 'P' + str(i)
body_l = np.random.normal(200, std) # body 치수 데이터 생성
body_l = round(body_l, 5)
body_w = np.random.normal(100, std) # body 치수 데이터 생성
body_w = round(body_w, 5)
body_h = np.random.normal(50, std) # body 치수 데이터 생성
body_h = round(body_h, 5)
op10_time_stamp = datetime.now() + timedelta(hours=9)
body.append(product_key_W1)
body.append(body_l)
body.append(body_w)
body.append(body_h)
body.append(op10_process_time)
body.append(op10_time_stamp) # 시작 시간
time.sleep(10) # 공정 실행
# 공정들 6개 실행
op60_data = machine_operate.op60(op50_WIP)
op50_data = machine_operate.op50(op40_WIP)
op40_data = machine_operate.op40(op30_WIP)
op30_data = machine_operate.op30(op20_WIP)
op20_data = machine_operate.op20(op10_WIP)
op10_data = machine_operate.op10(body)
total_test_data.append(op30_data)
total_test_data.append(op20_data)
total_test_data.append(op10_data)
op10_data = total_test_data.pop(0)
op20_data = total_test_data.pop(0)
op30_data = total_test_data.pop(1)
pred = Predict.predict_quality(op10_data, op20_data, op30_data)
print('P' + str(i - 2) + ' 품질 예측값: ' + str(pred))
MySQL_query.insert_product_prediction(op30_data, op20_data,
op10_data, pred)
now_product = op60_data['product_key']
print('6개 생산 완료! %s 제품이 생산되었습니다.' % (now_product))
return "공정 실행 완료!"