From 25bb2014c57a9f193b434747ac1b112a0154ddf6 Mon Sep 17 00:00:00 2001
From: Jiacheng Huang <chonpcaacpnohc@gmail.com>
Date: Thu, 12 Oct 2023 04:14:23 +0000
Subject: [PATCH] Upload New File
---
ESP-32/Controller.py | 707 +++++++++++++++++++++++++++++++++++++++++++
1 file changed, 707 insertions(+)
create mode 100644 ESP-32/Controller.py
diff --git a/ESP-32/Controller.py b/ESP-32/Controller.py
new file mode 100644
index 0000000..a52e5df
--- /dev/null
+++ b/ESP-32/Controller.py
@@ -0,0 +1,707 @@
+# This file is executed on every boot (including wake-boot from deepsleep)
+#import esp
+#esp.osdebug(None)
+#import webrepl
+#webrepl.start()
+import network
+import utime as time
+
+#ssid = "This man belongs to charming Emi"
+#password = "cjh961018"
+
+ssid = "Pilab494"
+password = "Pilab494"
+
+#ssid = 'pilab-494'
+#password = 'pilab-494'
+
+station = network.WLAN(network.STA_IF)
+
+station.active(True)
+
+time.sleep(5)
+
+station.connect(ssid, password)
+
+print(station.isconnected())
+
+
+while station.isconnected() == False:
+
+ print('connecting now')
+
+ time.sleep(1)
+
+print('connected')
+
+
+
+import urequests as requests
+
+databese_web = 'http://101.34.0.108:2000/'
+
+
+def get_previes_experiment():
+
+ create_url = databese_web + 'get_previous_experiment'
+
+ res = requests.post(create_url)
+
+ data = ['Connection Lost',]
+
+ if res.status_code == 200:
+
+ data = dict(res.json())['msg']
+
+ return data
+
+
+def creat_new_process(create_time):
+
+ create_url = databese_web + 'creat_new_process'
+
+ payload = { "time": create_time }
+
+ res = requests.post(create_url, json=payload)
+
+ work = 0
+
+ if res.status_code == 200:
+
+ if res.json()['msg']:
+
+ work = 1
+
+ return work
+
+
+def update_database(create_time, index, x, y):
+
+ create_url = databese_web + 'update_database'
+
+ payload = { "time": create_time, 'index': index, 'x': x, 'y': y }
+
+ res = requests.post(create_url, json=payload)
+
+ work = 0
+
+ if res.status_code == 200:
+
+ if res.json()['msg']:
+
+ work = 1
+
+ return work
+
+
+def update_index(create_time, index, data):
+
+ create_url = databese_web + 'update_index'
+
+ payload = { "time": create_time, 'index': index, 'data': data}
+
+ res = requests.post(create_url, json=payload)
+
+ work = 0
+
+ if res.status_code == 200:
+
+ if res.json()['msg']:
+
+ work = 1
+
+ return work
+
+
+def lookup_database(create_time, index, cur):
+
+ create_url = databese_web + 'lookup_database'
+
+ payload = { "time": create_time, 'index': index, 'cur': cur}
+
+ res = requests.post(create_url, json=payload)
+
+ if res.status_code == 200:
+
+ return res.json()['x'], res.json()['y']
+
+ else:
+
+ return [], []
+
+def lookup_index(create_time, index):
+
+ create_url = databese_web + 'lookup_index'
+
+ payload = { "time": create_time, 'index': index}
+
+ res = requests.post(create_url, json=payload)
+
+ if res.status_code == 200:
+
+ return res.json()['data']
+
+ else:
+
+ return []
+
+def lookup_cab(create_time):
+
+ create_url = databese_web + 'lookup_cab'
+
+ payload = { "time": create_time}
+
+ res = requests.post(create_url, json=payload)
+
+ if res.status_code == 200:
+
+ return res.json()['data']
+
+ else:
+
+ return []
+
+
+def lookup_work():
+
+ create_url = databese_web + 'lookup_work'
+
+ res = requests.post(create_url)
+
+ if res.status_code == 200:
+
+ return res.json()['data']
+
+ else:
+
+ return []
+
+
+def F(create_time, control_data, sensor_data):
+
+ create_url = databese_web + 'F'
+
+ payload = { "time": create_time, "control_data": str(control_data), "sensor_data": str(sensor_data)}
+
+ res = requests.post(create_url, json=payload)
+
+ if res.status_code == 200:
+
+ return res.json()['send_control_data']
+
+ else:
+
+ return []
+
+
+
+
+
+from machine import Pin, ADC, PWM
+import onewire
+import ds18x20
+
+pumps = [15,13,4,5,18,19,22] # pump1, pump2, pump3, pump4, pump5, pump6, pump7
+sensors = [34,32] # pH, Temp
+heat = [2] # heat
+air = [21] # Air
+
+pumps_pin = []
+sensors_pin = []
+heat_pin = []
+air_pin = []
+
+
+for i in pumps:
+ pumps_pin.append(Pin(i,Pin.OUT))
+ pumps_pin[-1].off()
+
+for i in sensors:
+ sensors_pin.append(Pin(i))
+
+ph = ADC(sensors_pin[0],atten = ADC.ATTN_11DB)
+
+
+
+ow = onewire.OneWire(sensors_pin[1])
+
+ds = ds18x20.DS18X20(ow)
+
+roms = ds.scan()
+
+ds.convert_temp()
+
+time.sleep(1)
+
+feedback = ds.read_temp(roms[0])
+
+print(feedback)
+
+
+for i in heat:
+ heat_pin.append(Pin(i,Pin.OUT))
+ heat_pin[-1].off()
+
+for i in air:
+ air_pin.append(PWM(Pin(i)))
+ air_pin[-1].freq(10)
+ air_pin[-1].duty(0)
+
+class PID:
+
+ def __init__(self, P=0.2, I=0.0, D=0.0):
+
+ self.Kp = P
+
+ self.Ki = I
+
+ self.Kd = D
+
+ self.sample_time = 0.00
+
+ self.current_time = time.time()
+
+ self.last_time = self.current_time
+
+ self.clear()
+
+ def clear(self):
+
+ self.SetPoint = 0.0
+
+ self.PTerm = 0.0
+
+ self.ITerm = 0.0
+
+ self.DTerm = 0.0
+
+ self.last_error = 0.0
+
+ self.int_error = 0.0
+
+ self.windup_guard = 20.0
+
+ self.output = 0.0
+
+ def update(self, feedback_value):
+
+ error = self.SetPoint - feedback_value
+
+ self.current_time = time.time()
+
+ delta_time = self.current_time - self.last_time
+
+ delta_error = error - self.last_error
+
+ if (delta_time >= self.sample_time):
+
+ self.PTerm = self.Kp * error # 比例
+
+ self.ITerm += error * delta_time # 积分
+
+ if (self.ITerm < -self.windup_guard):
+
+ self.ITerm = -self.windup_guard
+
+ elif (self.ITerm > self.windup_guard):
+
+ self.ITerm = self.windup_guard
+
+ self.DTerm = 0.0
+
+ if delta_time > 0:
+
+ self.DTerm = delta_error / delta_time
+
+ self.last_time = self.current_time
+
+ self.last_error = error
+
+ self.output = self.PTerm + (self.Ki * self.ITerm) + (self.Kd * self.DTerm)
+
+ def setKp(self, proportional_gain):
+
+ self.Kp = proportional_gain
+
+ def setKi(self, integral_gain):
+
+ self.Ki = integral_gain
+
+ def setKd(self, derivative_gain):
+
+ self.Kd = derivative_gain
+
+ def setWindup(self, windup):
+
+ self.windup_guard = windup
+
+ def setSampleTime(self, sample_time):
+
+ self.sample_time = sample_time
+
+
+
+import uasyncio
+
+async def blink(led, period_ms):
+
+ led.on()
+
+ await uasyncio.sleep_ms(int(5*1000*period_ms/100))
+
+ led.off()
+
+async def temp_read():
+
+ await uasyncio.sleep_ms(4_000)
+
+ ds.convert_temp()
+
+async def air(led,period_ms):
+
+ led.duty(int(period_ms/100*1000))
+
+
+async def main(control_data):
+
+ uasyncio.create_task(blink(pumps_pin[0], control_data[0]))
+
+ uasyncio.create_task(blink(pumps_pin[1], control_data[1]))
+
+ uasyncio.create_task(blink(pumps_pin[2], control_data[2]))
+
+ uasyncio.create_task(blink(pumps_pin[3], control_data[3]))
+
+ uasyncio.create_task(blink(pumps_pin[4], control_data[4]))
+
+ uasyncio.create_task(blink(pumps_pin[5], control_data[5]))
+
+ uasyncio.create_task(blink(pumps_pin[6], control_data[6]))
+
+ uasyncio.create_task(blink(heat_pin[0], control_data[7]))
+
+ uasyncio.create_task(air(air_pin[0], control_data[8]))
+
+ uasyncio.create_task(temp_read())
+
+ await uasyncio.sleep_ms(5_000)
+
+
+
+
+# ssid = "Pilab494"
+
+# password = "Pilab494"
+
+# station = network.WLAN(network.STA_IF)
+
+# station.active(True)
+
+# time.sleep(5)
+
+# station.connect(ssid, password)
+
+# print(station.isconnected())
+
+# while station.isconnected() == False:
+
+# print('connecting now')
+
+# time.sleep(1)
+
+# print('connected')
+
+
+start_time = time.time()
+cab = False
+
+
+ph_average = []
+
+while True:
+
+# try:
+
+ create_time = lookup_work()
+
+ print(create_time)
+
+ now_time = time.time()
+
+
+ if not(cab):
+
+ time.sleep(1)
+
+ cab_now = lookup_cab(create_time)
+
+ print(cab_now)
+
+ if cab_now == [1,3,5,5,5,5,5,5,5]:
+
+ cab = True
+
+ data = lookup_database(create_time, 'Calibration-pH', -1)
+
+ vx, py = data[1], data[0]
+
+ k_list = []
+
+ b_list = []
+
+ k_list.append((py[0]-py[1])/(vx[0]-vx[1]))
+
+ k_list.append((py[1]-py[2])/(vx[1]-vx[2]))
+
+ k_list.append((py[0]-py[2])/(vx[0]-vx[2]))
+
+ b_list.append(py[0]-vx[0]*k_list[0])
+
+ b_list.append(py[1]-vx[1]*k_list[1])
+
+ b_list.append(py[0]-vx[0]*k_list[2])
+
+ phk = sum(k_list)/len(k_list)
+
+ phb = sum(b_list)/len(b_list)
+
+ pid1 = PID(0.8,0.6,0.005)
+
+ pid1.SetPoint = 37.0
+
+ pid1.setSampleTime(0.01)
+
+
+ pid2 = PID(0.01,0.001,0.00003)
+
+ pid2.SetPoint = 7.0
+
+ pid2.setSampleTime(0.01)
+
+ control_data = [0, 0, 0, 0, 0, 0, 0, 0, 0] # pump + heat + air
+
+ sensor_data = [0, 0]
+
+
+ else:
+
+ # Pump
+
+ for i in range(2,9):
+
+ if cab_now[i] == 0:
+
+ continue
+
+ elif cab_now[i] == 1:
+
+ pumps_pin[i-2].on()
+
+ elif cab_now[i] == 2:
+
+ pumps_pin[i-2].off()
+
+ elif cab_now[i] == 3:
+
+ pumps_pin[i-2].on()
+
+ time.sleep(60)
+
+ pumps_pin[i-2].off()
+
+ update_index(create_time, 'c_Pump' + str(i-1), 4)
+
+ elif cab_now[i] == 4:
+
+ continue
+
+ elif cab_now[i] == 5:
+
+ continue
+
+ # pH
+
+ if not(cab_now[0]):
+
+ if cab_now[1] == 0:
+
+ continue
+
+ elif cab_now[1] == 1:
+
+ start_ph_time = time.time()
+
+ while True:
+
+ now_ph_time = time.time()
+
+ if now_ph_time - start_ph_time < 60:
+
+ ph_data = ph.read()
+
+ update_database(create_time, 'd_pH', ph_data, ph_data)
+
+ time.sleep(0.1)
+
+ else:
+
+ break
+
+
+ elif cab_now[1] == 2:
+
+ continue
+
+ elif cab_now[1] == 3:
+
+ continue
+
+ else:
+
+ work = int(lookup_index(create_time, 'p_Work'))
+
+ print(work)
+
+ if work == 1:
+
+ try:
+
+ feedback1 = ds.read_temp(roms[0])
+
+ pid1.update(feedback1)
+
+ operation1 = pid1.output/10*100
+
+ print(feedback1)
+
+
+
+ control_data[7] = min(max(operation1,0),100)
+
+ sensor_data[1] = feedback1
+
+
+ print(control_data[7])
+
+
+
+ feedback2 = ph.read()
+
+ if len(ph_average) < 5:
+
+ ph_average.append(feedback2)
+
+ else:
+
+ ph_average = ph_average[1::]
+
+ ph_average.append(feedback2)
+
+ print(ph_average)
+
+ feedback2 = sum(ph_average)/len(ph_average)
+
+
+
+ trans_feedback2 = feedback2*phk + phb
+
+ print(trans_feedback2)
+
+
+ pid2.update(trans_feedback2)
+
+ operation2 = pid2.output/10*100
+
+
+ control_data[0] = min(max(operation2,0),100)
+
+ sensor_data[0] = trans_feedback2
+
+
+ print(control_data[0])
+
+
+ a = time.time()
+
+ uasyncio.run(main(control_data))
+
+ b = time.time()
+
+ print(b-a)
+
+
+ send_control_data = F(create_time, control_data, sensor_data)
+
+
+ control_data[1] = send_control_data[1]
+
+ control_data[2] = send_control_data[2]
+
+ control_data[3] = send_control_data[3]
+
+ control_data[4] = send_control_data[4]
+
+ control_data[5] = send_control_data[5]
+
+ control_data[6] = send_control_data[6]
+
+ control_data[7] = send_control_data[7]
+
+ pid1.SetPoint = send_control_data[9]
+
+ pid2.SetPoint = send_control_data[8]
+
+ control_data[8] = send_control_data[10]
+
+
+
+
+ except:
+
+
+# a = time.time()
+#
+# uasyncio.run(main(control_data))
+#
+# b = time.time()
+#
+# print('nimabi')
+#
+# print(b-a)
+
+
+# send_control_data = F(create_time, control_data, sensor_data)
+
+
+ control_data[1] = send_control_data[1]
+
+ control_data[2] = send_control_data[2]
+
+ control_data[3] = send_control_data[3]
+
+ control_data[4] = send_control_data[4]
+
+ control_data[5] = send_control_data[5]
+
+ control_data[6] = send_control_data[6]
+
+ control_data[7] = send_control_data[7]
+
+ pid1.SetPoint = send_control_data[9]
+
+ pid2.SetPoint = send_control_data[8]
+
+ control_data[8] = send_control_data[10]
+
+
+ else:
+
+ time.sleep(5)
+
+ print('Rest')
+
+
+# except:
+#
+# print('Fuck')
+
--
GitLab