• 基于树莓派的蓄电池控制系统

    总概：

    (1)使用 Raspberry 4B作为主控芯片，通过不同模块采集信息。

    (2)搭建BP神经网络模型并训练，根据采集信息算出蓄电池的补水量。

    (3)使用PyQT编写人机交互界面。

    硬件准备：

    Raspberry Pi 4B

    PT1000温度传感器

    MAX31865放大器

    超声波测距传感器

    模数转换器

    比重检测模块

     

    总体连接图

    环境配置：

    树莓派新板子配置可以看我之前的博客，有详细介绍树莓派开机

    蓝牙配置

    以下是DM35密度仪蓝牙配置及数据传输

     

    Blueman插件

    在树莓派上将所需依赖安装上

    sudo apt update && sudo apt upgrade

    sudo apt install bluetooth pi-bluetooth bluez blueman

     

    之后右上角就出线了蓝牙的图标，可以通过GUI点击蓝牙配对比重仪并且信任该设备，或者通过以下命令行：

    sudo bluetoothctl

    scan on

    pair XX:XX:XX:XX:XX:XX

    connect XX:XX:XX:XX:XX:XX

    exit

    当比重仪点击发送数据后，树莓派就能接受到数据

    发送的是一个Iso8859编码格式的txt文件

    这里使用正则表达式将比重、温度、密度等需要信息提取出来

     

    屏幕驱动

    可以上LCDWIKI找到具体的LCD信号及其驱动文件。

    按照步骤一步一步配置即可，注意的是有些触摸板上是power和touch接口，并不是下图这种双power接口，所以接线时除了HDMI还需要接touch线而不接power线。

     

    软件编写

    写得很烂，完全没有去耦合，能跑就行

    1. #用到的python解释库导入
    2. import re
    3. from PyQt5.QtWidgets import QLabel,QLineEdit
    4. from PyQt5.QtCore import QTimer,QDateTime, QSize, Qt
    5. from PyQt5.QtWidgets import QApplication, QMainWindow, QPushButton, QComboBox
    6. from PyQt5.QtGui import *
    7.  
    8. import sys
    9. import os
    10.  
    11. import numpy as np
    12. import pandas as pd
    13. from matplotlib import pyplot as plt
    14. from openpyxl.styles.builtins import output
    15. import time
    16. import board
    17. import digitalio
    18. import adafruit_max31865
    19. import ADS1263.ADS1263 as AD
    20. import RPi.GPIO as GPIO
    21.  
    22. os.environ["QT_IM_MODULE"] = "qtvirtualkeyboard"
    23.  
    24. #接下来这部分是BP神经网络的内容
    25.  
    26. #定义每一层之间用到的传递函数
    27. def sigmoid(x):
    28.     # 第一层到第二层的激活函数
    29.     return 1 / (1 + np.exp(-x))
    30.  
    31. def deriv_sigmoid(x):
    32.     # 第一层到第二层的激活函数的求导函数
    33.     fx = sigmoid(x)
    34.     return fx * (1 - fx)
    35.  
    36. def mse_loss(y_true, y_pred):
    37.     # 使用方差作为损失函数
    38. return ((y_true - y_pred) ** 2).mean()
    39.  
    40. #开始神经网络的建立过程
    41. class OurNeuralNetwork:
    42.  
    43.     def __init__(self):
    44.         # 第一层到第二层的权重初始值设置
    45.         self.w11 = np.random.normal()
    46.         self.w12 = np.random.normal()
    47.         self.w13 = np.random.normal()
    48.         self.w14 = np.random.normal()
    49.         self.w21 = np.random.normal()
    50.         self.w22 = np.random.normal()
    51.         self.w23 = np.random.normal()
    52.         self.w24 = np.random.normal()
    53.         # 第二层到第三层的权重初始值设置
    54.         self.w1 = np.random.normal()
    55.         self.w2 = np.random.normal()
    56.         # 每一层截距项的初始值设置，Biases
    57.         self.b1 = np.random.normal()
    58.         self.b2 = np.random.normal()
    59.         self.b3 = np.random.normal()
    60.  
    61.      # 前向传播学习函数
    62.     def feedforward(self, x):
    63.         h1 = sigmoid(self.w11 * x[0] + self.w12 * x[1] + self.w13 * x[2] + self.w14 * x[3] + self.b1)
    64.         h2 = sigmoid(self.w21 * x[0] + self.w22 * x[1] + self.w23 * x[2] + self.w24 * x[3] + self.b1)
    65.         o1 = self.w1 * h1 + self.w2 * h2 + self.b3
    66.         return o1
    67.      #训练函数
    68.     def train(self, data, all_y_trues):
    69.         learn_rate = 0.001  # 学习率
    70.         epochs = 1000  # 训练的次数
    71.         # 画图数据
    72.         self.loss = np.zeros(100)
    73.         self.sum = 0
    74.         # 开始训练
    75.         for epoch in range(epochs):
    76.             for x, y_true in zip(data, all_y_trues):
    77.                 # 计算h1
    78.                 h1 = sigmoid(self.w11 * x[0] + self.w12 * x[1] + self.w13 * x[2] + self.w14 * x[3] + self.b1)
    79.                 # 计算h2
    80.                 h2 = sigmoid(self.w21 * x[0] + self.w22 * x[1] + self.w23 * x[2] + self.w24 * x[3] + self.b2)
    81.                 #计算输出节点
    82.                 y_pred = self.w1 * h1 + self.w2 * h2 + self.b3
    83.                 # 反向传播计算导数
    84.                 d_L_d_ypred = -2 * (y_true - y_pred)
    85.                 d_ypred_d_w1 = h1
    86.                 d_ypred_d_w2 = h2
    87.                 d_ypred_d_b3 = 0
    88.                 d_ypred_d_h1 = self.w1
    89.                 d_ypred_d_h2 = self.w2
    90.                 sum_1=self.w11 * x[0] + self.w12 * x[1] + self.w13 * x[2] + self.w14 * x[3] + self.b1
    91.                 d_h1_d_w11 = x[0] * deriv_sigmoid(sum_1)
    92.                 d_h1_d_w12 = x[1] * deriv_sigmoid(sum_1)
    93.                 d_h1_d_w13 = x[2] * deriv_sigmoid(sum_1)
    94.                 d_h1_d_w14 = x[3] * deriv_sigmoid(sum_1)
    95.                 d_h1_d_b1 = deriv_sigmoid(sum_1)
    96.                 sum_2 = self.w21 * x[0] + self.w22 * x[1] + self.w23 * x[2] + self.w24 * x[3] + self.b2
    97.                 d_h1_d_w21 = x[0] * deriv_sigmoid(sum_2)
    98.                 d_h1_d_w22 = x[1] * deriv_sigmoid(sum_2)
    99.                 d_h1_d_w23 = x[2] * deriv_sigmoid(sum_2)
    100.                 d_h1_d_w24 = x[3] * deriv_sigmoid(sum_2)
    101.                 d_h1_d_b2 = deriv_sigmoid(sum_2)
    102.  
    103.                 # 梯度下降法
    104.                 self.w11 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_w11
    105.                 self.w12 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_w12
    106.                 self.w13 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_w13
    107.                 self.w14 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_w14
    108.                 self.b1 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_b1
    109.                 self.w21 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h1_d_w21
    110.                 self.w22 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h1_d_w22
    111.                 self.w23 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h1_d_w23
    112.                 self.w24 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h1_d_w24
    113.                 self.b2 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h1_d_b2
    114.                 self.w1 -= learn_rate * d_L_d_ypred * d_ypred_d_w1
    115.                 self.w1 -= learn_rate * d_L_d_ypred * d_ypred_d_w2
    116.                 self.b3 -= learn_rate * d_L_d_ypred * d_ypred_d_b3
    117.  
    118.             if epoch % 10 == 0:
    119.                 y_preds = np.apply_along_axis(self.feedforward, 1, data)
    120.                 loss = mse_loss(all_y_trues, y_preds)
    121.                 print("Epoch %d loss: %.3f" % (epoch, loss))
    122.                 self.loss[self.sum] = loss
    123.                 self.sum = self.sum + 1
    124.  
    125. # 训练数据文件导入
    126. FILENAME = "/home/pi/Downloads/data.xlsx"
    127. # 禁用科学计数法
    128. pd.set_option('float_format', lambda x: '%.3f' % x)
    129. np.set_printoptions(suppress=True,threshold=sys.maxsize)
    130. # 得到的DataFrame分别为补水量、密度、电压、高度、温度
    131. data = pd.read_excel(FILENAME, header=0, usecols="A,B,C,D,E")
    132. DataArray = data.values
    133. Y = DataArray[:, 0]
    134. X = DataArray[:, 1:5]
    135. X = np.array(X)#转化为array,自变量
    136. Y = np.array(Y)#转化为array，因变量
    137.  
    138. # 处理数据
    139. data = np.array(X)
    140. data_mean = np.sum(data, axis=0) / np.size(data, 0)
    141. data = (data - data_mean) / np.max(data)
    142. all_y_trues = np.array(Y)
    143. all_y_trues_mean = np.sum(all_y_trues) / np.size(all_y_trues)
    144. all_y_trues = (all_y_trues - all_y_trues_mean) / np.max(all_y_trues)
    145.  
    146. # 训练数据
    147. network = OurNeuralNetwork()
    148. network.train(data, all_y_trues)
    149.  
    150. # 输出神经网络参数
    151. print("w11-->%.3f" % network.w11)
    152. print("w12-->%.3f" % network.w12)
    153. print("w13-->%.3f" % network.w13)
    154. print("w14-->%.3f" % network.w14)
    155. print("w21-->%.3f" % network.w21)
    156. print("w22-->%.3f" % network.w22)
    157. print("w23-->%.3f" % network.w23)
    158. print("w24-->%.3f" % network.w24)
    159. print("w1-->%.3f" % network.w1)
    160. print("w2-->%.3f" % network.w2)
    161. print("b1-->%.3f" % network.b1)
    162. print("b2-->%.3f" % network.b2)
    163. print("b3-->%.3f" % network.b3)
    164.  
    165.  
    166. #这部分是人机界面的建立过程
    167. class Stats():
    168.     def __init__(self):
    169.         #主窗口设计参数
    170.         self.window = QMainWindow()
    171.         self.window.showFullScreen()
    172.         self.window.move(0, 0)
    173.         self.window.setWindowTitle('测控界面')
    174.         self.window.setWindowFlags(Qt.FramelessWindowHint)
    175.         self.window.setObjectName("MainWindow")
    176.         self.window.setStyleSheet("#MainWindow{border-image:url(bg.jpg)}")
    177.         self.state = True
    178.  
    179.         self.wendu = QLabel('温度(°)', self.window)                  # 温度按钮
    180.         self.wendu.setGeometry(80, 200, 150, 60)  # （x坐标，y坐标，宽，高）
    181.  
    182.         self.tem = 0
    183.         self.Label1 = QLineEdit(f'{self.tem}', self.window)               # 单文本框1：温度显示值
    184.         self.Label1.setGeometry(250, 200, 150, 60)  # （x坐标，y坐标，宽，高）
    185.         self.Label1.setAlignment(Qt.AlignCenter)                             # 设置文本框中内容居中
    186.  
    187.         self.bizhong = QLabel('密度(g/cm3)', self.window)                     # 比重按钮
    188.         self.bizhong.setGeometry(80, 350, 150, 60)  # （x坐标，y坐标，宽，高）
    189.  
    190.         self.midu = 0
    191.         self.Label4 = QLineEdit(f'{self.midu}', self.window)               # 单文本框4：比重显示值
    192.         self.Label4.setGeometry(250, 350, 150, 60)  # （x坐标，y坐标，宽，高）
    193.         self.Label4.setAlignment(Qt.AlignCenter)                             # 设置文本框中内容居中
    194.  
    195.         self.gaodu = QLabel('高度(cm)', self.window)                   # 高度按钮
    196.         self.gaodu.setGeometry(640, 200, 150, 60)  # （x坐标，y坐标，宽，高）
    197.  
    198.         self.hei = 0
    199.         self.Label2 = QLineEdit(f'{self.hei}', self.window)           # 单文本框2：高度显示值
    200.         self.Label2.setGeometry(810, 200, 150, 60)  # （x坐标，y坐标，宽，高）
    201.         self.Label2.setAlignment(Qt.AlignCenter)                             # 设置文本框中内容居中
    202.  
    203.         self.bushui = QLabel('水量(ml)', self.window)               # 补水量按钮
    204.         self.bushui.setGeometry(640, 350, 150, 60)  # （x坐标，y坐标，宽，高）
    205.  
    206.         self.shui = 0
    207.         self.Label3 = QLineEdit(f'{self.shui}', self.window)           # 单文本框3：补水量显示值
    208.         self.Label3.setGeometry(810, 350, 150, 60)  # （x坐标，y坐标，宽，高）
    209.         self.Label3.setAlignment(Qt.AlignCenter)                             # 设置文本框中内容居中
    210.  
    211.         self.ceshi = QPushButton('刷新', self.window)                   # 开始按钮，点击来对此时测量量进行显示以及赋值
    212.         self.ceshi.setGeometry(100, 100, 60, 30)  # （x坐标，y坐标，宽，高）
    213.         self.ceshi.clicked.connect(self.handleCalc)
    214.  
    215.  
    216.         self.caculate_out_label = QLabel('补水量',self.window)
    217.         self.caculate_out_label.setGeometry(100, 50, 60, 30)  # （x坐标，y坐标，宽，高）
    218.         self.caculate_out_label.setAlignment(Qt.AlignCenter)
    219.  
    220.         self.Ncalculate_data=0
    221.         self.caculate_outData_label = QLabel(f'{self.Ncalculate_data}',self.window)                           # 在self.window窗口添加一个标签time_label
    222.         self.caculate_outData_label.setGeometry(180, 50, 60, 30)  # （x坐标，y坐标，宽，高）
    223.         self.caculate_outData_label.setAlignment(Qt.AlignCenter)
    224.  
    225.         self.state_label = QLabel(f'OK',self.window)                           # 在self.window窗口添加一个标签time_label
    226.         self.state_label.setGeometry(250, 50, 60, 30)  # （x坐标，y坐标，宽，高）
    227.         self.state_label.setAlignment(Qt.AlignCenter)
    228.  
    229.         self.time_label = QLabel(self.window)                           # 在self.window窗口添加一个标签time_label
    230.         self.time_label.setGeometry(700, 0, 300, 200)  # （x坐标，y坐标，宽，高）
    231.         self.time_label.setAlignment(Qt.AlignCenter)                    # 函数setAlignment()主要将是消除布局中的空隙，让两个控件紧紧挨在一起
    232.         self.Timer = QTimer()                                           # 创建定时器
    233.         self.Timer.start(500)                                           # 定时器每500ms工作一次
    234.         self.Timer.timeout.connect(self.TimeUpdate)                     # 500指的是500ms，即每500ms调用一下这个TimeUpdate函数
    235.                                                                         # 建立定时器连接通道  注意这里调用TimeUpdate方法，不是方法返回的的结果，所以不能带括号， # 写成self.TimeUpdate()是不对的，带括号代表返回值
    236.  
    237.         self.setup = QPushButton('设置', self.window)                    # 设置按钮：点击进入下一界面
    238.         self.setup.setGeometry(300, 100, 60, 30)  # （x坐标，y坐标，宽，高）
    239.         self.setup.clicked.connect(self.call_dialog)
    240.  
    241.         self.Ncalculate = QPushButton('计算', self.window)                   # 开始按钮，点击来对此时测量量进行显示以及赋值
    242.         self.Ncalculate.setGeometry(200, 100, 60, 30)  # （x坐标，y坐标，宽，高）
    243.         self.Ncalculate.clicked.connect(self.Ncalculate_handle)
    244.  
    245.         # 电池类型选择：模式一，模式二，模式三分别代表不同的电池组类型
    246.         self.moshi = QComboBox(self.window)
    247.         self.moshi.setGeometry(400, 100, 110, 30)  # （x坐标，y坐标，宽，高）
    248.         self.moshi.addItem("模式1")
    249.         self.moshi.addItem("模式2")
    250.         self.moshi.addItem("模式3")
    251.  
    252.  
    253.  
    254.     # 下面是前面用到的函数功能定义总结
    255.     # 函数一：用于变量显示
    256.     def handleCalc(self):                                                # 开始按钮对应的函数  def handleCalc(self):
    257.  
    258.  
    259. # 通过SPI通讯读取MAX31865上面的数据（读取热电偶输出值）
    260.             spi = board.SPI()
    261.             cs = digitalio.DigitalInOut(board.D5)  # Chip select of the MAX31865 board.
    262.             sensor = adafruit_max31865.MAX31865(spi, cs, rtd_nominal=1000.0, ref_resistor=4300.0, wires=4)
    263.             print("Temperature: {0:0.3f}C".format(sensor.temperature))
    264.             print("resistance: {0:0.3f} Ohms".format(sensor.resistance))
    265.             self.tem = round(sensor.temperature,2)
    266.             self.temperature=sensor.temperature
    267. # 通过SPI通讯分时复用读取ADS1263上面的数据（读取超声波传感器上输出值）
    268.             REF = 5.08  # Modify according to actual voltage
    269.             try:
    270.                 ADC = AD.ADS1263()
    271.                 if (ADC.ADS1263_init_ADC1('ADS1263_7200SPS') == -1):
    272.                     exit()
    273.                 ADC.ADS1263_SetMode(0)
    274.                 self.ADC_Value = ADC.ADS1263_GetAll()  # get ADC1 value
    275.                 self.height = self.ADC_Value[1] * REF / 0x7fffffff
    276.                 print("ADC1 IN1 = %lf" % self.height)  # 32bit
    277.                 self.hei=round(self.height, 2)
    278.             except IOError as e:
    279.                 print(e)
    280.  
    281.  
    282.             self.buttonLabel1 = f'{self.tem}'
    283.             self.Label1.setText(self.buttonLabel1)                         # 改变标签1的函数，给标签1赋当前温度值
    284.  
    285.             self.buttonLabel2 = f'{self.hei}'
    286.             self.Label2.setText(self.buttonLabel2)                        # 改变标签1的函数，给标签2赋当前温度值
    287.  
    288.             try:
    289.                 f = open('./measureLog_export.txt',encoding='iso8859')
    290.             except:
    291.                 self.Density=0
    292.                 print(f'bluetooth error:not file')
    293.                 self.state = False
    294.             else:
    295.                 read_data_line=f.readlines()
    296.                 f.close()
    297.                 read_data_line_count=len(read_data_line)
    298.                 os.remove("./measureLog_export.txt")
    299.  
    300.                 regex = re.compile("[0-9]+.*[0-9]")
    301.                 search_data=regex.search(read_data_line[read_data_line_count-6])
    302.                 SampleID=str(search_data.group())
    303.                 print(f'SampleID is {SampleID}')
    304.  
    305.  
    306.                 regex = re.compile("[0-9]+.*[0-9]")
    307.                 search_data=regex.search(read_data_line[read_data_line_count-5])
    308.                 self.Density=float(search_data.group())
    309.                 print(f'Density is {self.Density}')
    310.  
    311.                 regex = re.compile("[0-9]+.*[0-9]")
    312.                 search_data=regex.search(read_data_line[read_data_line_count-3])
    313.                 SG=float(search_data.group())
    314.                 print(f'SG is {SG}')
    315.                 self.state = True
    316.  
    317.  
    318.             self.midu=round(self.Density, 2)
    319.  
    320.             self.buttonLabel4 = f'{self.midu}'
    321.             self.Label4.setText(self.buttonLabel4)
    322.  
    323.             info = self.moshi.currentText()                              # 提取模式多组合选择里面的文本出来，此时文本包括字符串以及数字
    324.             salary = re.sub("\D", "", info)                              # 提取info里面的数字出来
    325.  
    326.             if int(salary) == 1:                                         # 根据模式不同，赋给按钮6补水量的值也有所不同
    327.                     self.shui = 10
    328.                     self.buttonLabel3 = f'{self.shui}'
    329.                     self.Label3.setText(self.buttonLabel3)              # 改变按钮6标签的函数
    330.             if int(salary) == 2:
    331.                     self.shui = 20
    332.                     self.buttonLabel3 = f'{self.shui}'
    333.                     self.Label3.setText(self.buttonLabel3)  # 改变按钮6标签的函数
    334.             if int(salary) == 3:
    335.                     self.shui = 30
    336.                     self.buttonLabel3 = f'{self.shui}'
    337.                     self.Label3.setText(self.buttonLabel3)  # 改变按钮6标签的函数
    338.  
    339.  
    340.     # 函数二：用于时间刷新，实时时间显示:目前是调用当前电脑上时间
    341.     def TimeUpdate(self):
    342.         self.time_label.setText(QDateTime.currentDateTime().toString('yyyy-MM-dd hh:mm:ss dddd'))
    343.         if self.state == False :
    344.             self.state_label.setText('Error')
    345.         else :
    346.             self.state_label.setText('OK')
    347.  
    348.     def is_number(self,s):
    349.         pattern = re.compile(r'^[-+]?[-0-9]\d*\.\d*|[-+]?\.?[0-9]\d*$')
    350.         result = pattern.match(s)
    351.         if result:
    352.             return True
    353.         else:
    354.             return False
    355.  
    356.     def Ncalculate_handle(self):
    357.  
    358.         calculate_data_Density=self.Label4.text()
    359.         if not self.is_number(calculate_data_Density):
    360.             calculate_data_Density = 0
    361.             print('Density input is not number')
    362.             self.Label4.setText('0')
    363.             self.state = False
    364.         else :
    365.             calculate_data_Density = float(calculate_data_Density)
    366.         if  calculate_data_Density==self.midu :
    367.             calculate_data_Density=self.Density
    368.         else :
    369.             self.state = True
    370.  
    371.  
    372.         calculate_data_temperature=self.Label1.text()
    373.         if not self.is_number(calculate_data_temperature):
    374.             calculate_data_temperature = 0
    375.             print('Temperature input is not number')
    376.             self.state = False
    377.             self.Label1.setText('0')
    378.         else :
    379.             calculate_data_temperature = float(calculate_data_temperature)
    380.         if  calculate_data_temperature==self.tem :
    381.             calculate_data_temperature=self.temperature
    382.  
    383.         calculate_data_shui=self.Label3.text()
    384.         if not self.is_number(calculate_data_shui):
    385.             calculate_data_shui = 0
    386.             print('Water input is not number')
    387.             self.state = False
    388.             self.Label3.setText('0')
    389.         else :
    390.             calculate_data_shui = float(calculate_data_shui)
    391.         if  calculate_data_shui==self.shui :
    392.             calculate_data_shui=self.shui
    393.  
    394.         calculate_data_height=self.Label2.text()
    395.         if not self.is_number(calculate_data_height):
    396.             calculate_data_height = 0
    397.             print('Height input is not number')
    398.             self.state = False
    399.             self.Label2.setText('0')
    400.         else :
    401.             calculate_data_height = float(calculate_data_height)
    402.         if  calculate_data_height==self.hei :
    403.             calculate_data_height=self.height
    404.  
    405.         self.k1 = calculate_data_Density
    406.         self.k2 = calculate_data_height
    407.         self.k3 = calculate_data_shui
    408.         self.k4 = calculate_data_temperature
    409.         z = [self.k1, self.k2, self.k3, self.k4]
    410.         z = (z - data_mean) / np.max(data)
    411.         z1 = z[0]
    412.         z2 = z[1]
    413.         z3 = z[2]
    414.         z4 = z[3]
    415.  
    416.         self.h1 = sigmoid(network.w11 * z1 + network.w12 * z2 + network.w13 * z3 + network.w14 * z4 + network.b1)
    417.         self.h2 = sigmoid(network.w21 * z1 + network.w22 * z2 + network.w23 * z3 + network.w24 * z4 + network.b2)
    418.         self.output = network.w1 * self.h1 + network.w2 * self.h2 + network.b3
    419.         self.output = self.output * np.max(all_y_trues) + all_y_trues_mean
    420.         self.d1 = round(self.output, 2)  # 0.0005 is changed as 0.05
    421.  
    422.         self.Ncalculate_data=self.d1
    423.         self.caculate_outData_label.setText(f'{self.Ncalculate_data}')
    424.  
    425.         print(f'Neural Networks OutPut is {self.d1}')
    426.  
    427.     # 函数三：点击设置按钮后用于主界面的关闭与子界面1的打开
    428.     def call_dialog(self):
    429.         self.childwindow = QMainWindow()                                 # 子界面childwindow的设置
    430.         self.childwindow.resize(400, 300)
    431.         self.childwindow.move(300, 100)
    432.         self.childwindow.setWindowTitle('设置界面')
    433.  
    434.  
    435.         self.save = QPushButton('返回', self.childwindow)                 # 存储按钮
    436.         self.save.move(80, 200)
    437.         self.save.clicked.connect(self.back)
    438.  
    439.         self.language = QPushButton('语言', self.childwindow)             # 语言按钮
    440.         self.language.move(80, 40)
    441.         self.language.clicked.connect(self.call_dialog2)
    442.  
    443.         self.test = QPushButton('校零', self.childwindow)                 # 校零按钮
    444.         self.test.move(80, 120)
    445.         self.test.clicked.connect(self.backzero)
    446.  
    447.  
    448.         self.childwindow.show()
    449.  
    450.         # 函数四 语言按钮的子窗口2
    451.     def call_dialog2(self):
    452.         self.childwindow2 = QMainWindow()                                 # 子界面childwindow的设置
    453.         self.childwindow2.resize(400, 300)
    454.         self.childwindow2.move(300, 100)
    455.         self.childwindow2.setWindowTitle('语言界面')
    456.  
    457.         self.foreign = QPushButton('英语', self.childwindow2)                 # 存储按钮
    458.         self.foreign.move(80, 40)
    459.         self.foreign.clicked.connect(self.English)
    460.  
    461.         self.china = QPushButton('中文', self.childwindow2)             # 语言按钮
    462.         self.china.move(80, 120)
    463.         self.china.clicked.connect(self.Chinese)
    464.  
    465.         self.childwindow.close()
    466.         self.childwindow2.show()
    467.  
    468.     def English(self):
    469.         self.wendu.setText('Temeratiure')
    470.         self.gaodu.setText('Height')
    471.         self.ceshi.setText('Begin')
    472.         self.bizhong.setText('Density')
    473.         self.setup.setText('Setting')
    474.         self.save.setText('Save')
    475.         self.language.setText('Language')
    476.         self.test.setText('Test')
    477.         self.foreign.setText('English')
    478.         self.china.setText('Chinese')
    479.         self.save.setText('Save')
    480.  
    481.         self.childwindow2.close()
    482.         self.childwindow.show()
    483.  
    484.     def Chinese(self):
    485.         self.wendu.setText('温度')
    486.         self.gaodu.setText('高度')
    487.         self.ceshi.setText('刷新')
    488.         self.bizhong.setText('密度')
    489.         self.setup.setText('设置')
    490.         self.save.setText('存储')
    491.         self.language.setText('语言')
    492.         self.test.setText('校零')
    493.         self.foreign.setText('英语')
    494.         self.china.setText('中文')
    495.         self.save.setText('返回')
    496.  
    497.         self.childwindow2.close()
    498.         self.childwindow.show()
    499.  
    500.     # 函数五：点击返回按钮后用于子界面1的关闭与主界面的打开
    501.     def back(self):
    502.         self.childwindow.close()
    503.         self.window.show()
    504.  
    505.     # 函数六：点击返回按钮后用于子界面1的关闭与主界面的打开
    506.     def backzero(self):
    507.  
    508.         self.shui = 0
    509.         self.buttonLabel1 = f'{self.shui}c'
    510.         self.Label1.setText(self.buttonLabel1)                         # 改变单文本框1标签的函数，给赋当前温度值
    511.         self.buttonLabel2 = f'{self.shui}cm'
    512.         self.Label2.setText(self.buttonLabel2)                         # 改变单文本框2标签的函数，赋当前高度值
    513.         self.buttonLabel3 = f'{self.shui}ml'
    514.         self.Label3.setText(self.buttonLabel3)                         # 改变单文本框3标签的函数
    515.         self.buttonLabel4 = f'{self.shui}ml'
    516.         self.Label4.setText(self.buttonLabel4)                         # 改变单文本框4标签的函数
    517.         self.childwindow.close()
    518.         self.window.show()
    519.  
    520. app = QApplication([])
    521. stats = Stats()
    522. stats.window.show()
    523. app.exec_()
    524.

     

    为方便调试、测量数据，编写两套启动脚本

    auto_start_test.sh:不含神经网络计算，只为测量、调试，启动、运行更快

    auto_start.sh:含神经网络计算部分，先将测量后的数据进行训练学习，利用模型得出计算量

     

     

  • 相关阅读:
    以太坊路线图：合并之后 Rollup+分片是扩容关键
    mybatis 执行流程,mybatis源码解析，推荐收藏
    【小程序】基于SpringBoot开发的餐厅点餐系统
    MySQL 表分区简介
    Metabase学习教程：入门-3
    爬虫入门基础与Selenium反爬虫策略
    TCP/IP(十九)TCP 实战抓包分析(三)TCP 第一次握手 SYN 丢包
    以sqlilabs靶场为例，讲解SQL注入攻击原理【15-17关】
    KubeEdge设备接入的mqtt调试
    面试官：vue2和vue3的区别有哪些？
  • 原文地址：https://blog.csdn.net/qq_41495871/article/details/127809293