DCS/protocol/Celery/MBRTUSlave/MBRTUSTask.py

from celery import Task, shared_task

import os
import sys
import pickle
import time
import sqlite3
from peewee import *

sys.path.append('../../../')
sys.path.append('../')

from protocol.ModBus.rtuslave_example import RTUSlave
from protocol.Celery.MBRTUSlave import app

from protocol.Celery.MBTCPSlave.MBTCPSTask import ModBusTCPSTask

from utils.DBModels.BaseModel import *
from utils.DBModels.ProjectBaseModel import *

from utils.DBModels.ClientModels import ClientDB
from utils.DBModels.ProtocolModel import ModBusVar, RTUSetting
from model.ProjectModel.VarManage import ModbusVarManage


class ModBusRTUSTask(ModBusTCPSTask):
    _RtuSlave = None
    _setting = None
    _offset = None
    def __init__(self):
        super(ModBusRTUSTask, self).__init__()

    @property
    def rtuSlave(self):
        if self._RtuSlave is None:
            port = str(self.setting[0])
            bytesize = int(self.setting[1])
            baudrate = int(self.setting[2])
            stopbits = int(self.setting[3])
            parity = str(self.setting[4].split(' ')[0])
            self._RtuSlave = RTUSlave(port = port, baudrate = baudrate, bytesize = bytesize, parity = parity, stopbits = stopbits, xonxoff=0)
            self._RtuSlave.start()
        return self._RtuSlave

    @property
    def tcpSlave(self):
        return


    @property
    def setting(self):
        if self._setting is None:
            self.cursor.execute("select * from RTUSetting")
            allCon = self.cursor.fetchall()

            port = str(allCon[0][1])
            bytesize = int(allCon[0][2])
            baudrate = int(allCon[0][3])
            stopbits = int(allCon[0][4])
            parity = str(allCon[0][5].split(' ')[0])
            offset = int(allCon[0][-1])
            self._setting = [port, bytesize, baudrate, stopbits, parity, offset]
        return self._setting

    @property
    def offset(self):
        if self._offset is None:
            offset = self.setting[-1]
            self._offset = offset
        return self._offset




@app.task(base = ModBusRTUSTask, bind = True, priority = 5)
def readValues(self): # 读取变量
    # [var.id, var.varName, var.description, var.varType, var.slaveID, var.address, var.min, var.max]
    # varName = CharField()
    # varType = IntegerField()
    # createTime = CharField()
    # description = CharField()
    # address = CharField()
    # slaveID = CharField()
    # min = CharField()
    # max = CharField()
    # allVar = self.allVar
    self.cursor.execute("select * from ModBusVar")
    allVar = self.cursor.fetchall()
    varDict = {}
    if not allVar:
        return
    else:
        # print(allVar)
        for varMes in allVar:
            name = str(varMes[1])
            varType = str(varMes[2])
            slaveId = int(varMes[6])
            address = int(varMes[5]) - self.offset
            order = varMes[-1]
            try:
                self.rtuSlave.server.get_slave(slaveId)
            except:
                self.rtuSlave.addSlave(slaveId)
            # print(varType)
            if varType == '4':
                # varDict[name] = RTUModbus.readHoldingRegisters(slaveId = slaveId, startAddress = address, varNums = 1)
                curValue = self.rtuSlave.readValue(slaveId, '4', address, order = order)
            elif varType == '3':
                curValue = self.rtuSlave.readValue(slaveId, '3', address, order = order)
                # curValue = RTUModbus.readInputRegisters(slaveId = slaveId, startAddress = address, varNums = 1)
            elif varType == '0':
                curValue = self.rtuSlave.readValue(slaveId, '0', address, order = order)
                # curValue = RTUModbus.readCoils(slaveId = slaveId, startAddress = address, varNums = 1)
            elif varType == '1':
                curValue = self.rtuSlave.readValue(slaveId, '1', address, order = order)
            if curValue != 'error':
                self.influxDB.writeFun(str(name), curValue)
            varDict[name] = curValue

            try:
                value = app.backend.get(name).decode('utf-8')
                address2 = int(value.split(',')[0])
                if '.' in value:
                    value = float(value.split(',')[1])
                else:
                    value = int(value.split(',')[1])
                if address == address2:
                    self.rtuSlave.setValue(slaveId, varType, address, value, order = order)
                    app.backend.set(name, '')
            except Exception as e:
                print(e)
                # varDict[name] = RTUModbus.readInputCoils(slaveId = slaveId, startAddress = address, varNums = 1)

    app.backend.set('ModBus', str(self.request.id))
    # print(RTUModbus.readInputRegisters(slaveId = 2, startAddress =  0, varNums = 10))

    # print(RTUModbus.readCoils(slaveId = 3, startAddress = 0, varNums = 10))

    # print(RTUModbus.readInputCoils(slaveId = 4, startAddress = 0, varNums = 10))
    # print(varDict)
    return varDict


@shared_task(base = ModBusRTUSTask, bind = True, priority = 1)
def setValue(self, name, varType, slaveID, address, value): # 写入变量
    # print(id(self.rtuSlave))
    slaveID = int(slaveID)
    address = int(address) - self.offset
    # self.rtuSlave.setValue(slaveId, varType, address, value)
    app.backend.set(name, str(address) + ',' + str(value))
    # if varType == '1':
    #     RTUModbus.writeSingleRegister(slaveId = slaveID, address = address, outputValue = value)
    # elif varType == '3':
    #     RTUModbus.writeSingleCoil(slaveId = slaveID, address = address, outputValue = value)
    # else:
    #     return '错误的变量类型'
    return 'success'