Wie steuert man Longer Pumpen über das Modbus RTU-Protokoll?

				
					'''
-------------------------------------------------------------
Longer Peristaltic Pump Control Library Using Modbus Protocol 
-------------------------------------------------------------
'''

import serial
import time

#------------------------------------------------------#
#   LIBRARY MANAGING THE COMMUNICATION WITH THE PUMP   #
#------------------------------------------------------#

class Longer_Pump:
    
    # Initialize the class with serial communication parameters
    def __init__(self, port, address=1, baudrate=9600, parity=serial.PARITY_NONE, bytesize=8, stopbits=1, timeout=1):
        """
        Parameters:
        port (str): The COM port for serial communication.
        address (int): Modbus address of the pump (default is 1).
        baudrate (int): The baud rate (default is 9600).
        parity (str): Parity for serial communication (default is none).
        bytesize (int): Number of data bits (default is 8).
        stopbits (int): Number of stop bits (default is 1).
        timeout (int): Timeout for serial communication (default is 1s).
        """
        self.ser = serial.Serial(port=port, baudrate=baudrate, parity=parity, bytesize=bytesize, stopbits=stopbits, timeout=timeout)
        self.address = address

    # Open the serial port for communication with the pump
    def connect(self):
        if not self.ser.is_open:
            self.ser.open()

    # Close the serial port to end communication with the pump
    def disconnect(self):
        if self.ser.is_open:
            self.ser.close()

    # Calculate the CRC for Modbus communication
    def _calculate_crc(self, data):
        """
        Parameters:
            data (bytearray): The data for which to calculate the CRC.
        Returns:
            bytes: The calculated CRC as a 2-byte value.
        """
        crc = 0xFFFF
        for byte in data:
            crc ^= byte
            for _ in range(8):
                if crc & 0x0001:
                    crc >>= 1
                    crc ^= 0xA001
                else:
                    crc >>= 1
        return crc.to_bytes(2, byteorder='little')

    # Send a command to the pump using the Modbus protocol
    def _send_command(self, function_code, register_address, data):
        """
        Parameters:
            function_code (int): e.g., 0x03 for read, 0x06 for write.
            register_address (int): to read from or write to.
            data (list or int): to be sent (for writing registers).
        Returns:
            bytes: The response from the pump.
        """
        
        # Prepare the command payload for Modbus
        payload = bytearray([self.address, function_code])
        payload.extend(register_address.to_bytes(2, byteorder='big'))
        
        if isinstance(data, list):
            # For multi-register commands (function code 0x10)
            number_of_registers = len(data)
            payload.extend(number_of_registers.to_bytes(2, byteorder='big'))
            payload.append(len(data) * 2)  # Byte count for the data
            for value in data:
                payload.extend(value.to_bytes(2, byteorder='big'))
        else:
            # For single-register commands (function code 0x06)
            payload.extend(data.to_bytes(2, byteorder='big'))

        # Append CRC
        crc = self._calculate_crc(payload)
        payload.extend(crc)

        # Send the command to the pump
        self.ser.write(payload)
        response = self.ser.read(8)  # Adjust this based on expected response length
        return response

    # Set the pump speed in RPM (0.01 RPM increments)
    def set_speed(self, speed_rpm):
        """
        Parameters:
            speed_rpm (float): The desired speed in RPM.
        """
        speed_value = int(speed_rpm * 100)  # 0.01 RPM increments
        response = self._send_command(0x06, 0x01, speed_value)
        print(f"Set speed response: {response.hex()}")

    # Set the pump flow rate in mL/min (combined high/low bytes)
    def set_flow_rate(self, flow_rate_ml_min):
        """
        Parameters:
            flow_rate_ml_min (float): The desired flow rate in mL/min.
        """
        flow_rate_nl_min = int(flow_rate_ml_min * 1_000_000)  # Convert mL/min to nL/min
        high_byte = (flow_rate_nl_min >> 16) & 0xFFFF
        low_byte = flow_rate_nl_min & 0xFFFF
        response = self._send_command(0x10, 0x02, [high_byte, low_byte])
        print(f"Set flow rate response: {response.hex()}")

    # Start the pump and set the display mode to either 'speed' (RPM) or 'flow_rate' (mL/min)
    def start(self, display_mode="speed"):
        """
        Parameters:
            display_mode (str): 'speed' or 'flow_rate'.
        """
        if display_mode == "speed":
            pump_state = 0b00000001  # Run + Display Speed
        elif display_mode == "flow_rate":
            pump_state = 0b00000101  # Run + Display Flow Rate
        else:
            raise ValueError("Invalid display_mode. Use 'speed' or 'flow_rate'.")
        response = self._send_command(0x06, 0x04, pump_state)
        print(f"Start pump response: {response.hex()}")

    # Stop the pump and set the display mode to either 'speed' (RPM) or 'flow_rate' (mL/min)
    def stop(self, display_mode="speed"):
        """
        Parameters:
            display_mode (str): 'speed' or 'flow_rate'.
        """
        if display_mode == "speed":
            pump_state = 0b00000000  # Stop + Display Speed
        elif display_mode == "flow_rate":
            pump_state = 0b00000100  # Stop + Display Flow Rate
        else:
            raise ValueError("Invalid display_mode. Use 'speed' or 'flow_rate'.")
        response = self._send_command(0x06, 0x04, pump_state)
        print(f"Stop pump response: {response.hex()}")

    # Set the pump direction (CW or CCW)
    def set_direction(self, direction):
        """
        Parameters:
            direction (str): 'CW' for clockwise, 'CCW' for counter-clockwise.
        """
        direction_value = 0x0010 if direction.upper() == 'CCW' else 0x0000
        response = self._send_command(0x06, 0x04, direction_value)
        print(f"Set direction response: {response.hex()}")

    # Custom function: Run the pump at the specified speed for a certain amount of time and then stop
    def run(self, speed_rpm, run_time_s, direction='CW'):
        """
        Parameters:
            speed_rpm (float): The speed at which to run the pump in RPM.
            run_time_s (int): The time to run the pump in seconds.
            direction (str): 'CW' or 'CCW'.
        """
        try:
            self.set_speed(speed_rpm)
            self.set_direction(direction)
            self.start(display_mode="speed")
            # Run the pump for the specified time
            for remaining_time in range(run_time_s, 0, -1):
                print(f"Running... {remaining_time} seconds remaining")
                time.sleep(1)
        finally:
            self.stop(display_mode="speed")

#-----------------------------------------------------------------------#
#   EXAMPLES ON HOW TO USE THE DEFINED CLASS TO CONTROL A LONGER PUMP   #
#-----------------------------------------------------------------------#

pump = Longer_Pump(port='COM7', address=1)  # Adjust port and address as needed
pump.connect()

# Run the pump at 40 rpm
pump.set_speed(40.00)  # Speed in RPM
pump.start(display_mode="speed")  
pump.stop(display_mode="speed")  

# Set direction to counter-clockwise
pump.set_direction('CCW')

# Run the pump in flow rate mode at 35 mL/min
pump.set_flow_rate(35)  # Flow rate in mL/min
pump.start(display_mode="flow_rate")  
pump.stop(display_mode="flow_rate")  # Stop the pump

# Run the pump counter-clockwise at 10 RPM for 25 seconds
pump.run(speed_rpm=10.0, run_time_s=25, direction='CCW')

# Disconnect the pump
pump.disconnect()