Tích hợp biến tần với hệ thống SCADA/PLC: Hướng dẫn A-Z cho kỹ sư tự động hóa (2025)

Biến tần 1    Biến tần 2    PLC/Gateway
           A+    -------- A+    -------- A+ (D+)
           B-    -------- B-    -------- B- (D-)
          GND    -------- GND   -------- GND
           |                              |
         120Ω                           120Ω

P00.01 = 2    // Chế độ điều khiển: Terminal + Communication
        P14.00 = 1    // Giao thức: Modbus RTU
        P14.01 = 1    // Slave Address (ID thiết bị)
        P14.02 = 9600 // Baudrate
        P14.03 = 0    // Data format: 8-N-1
        P14.04 = 2    // Response delay: 2ms

H03 = 1       // RS485 enable
        H04 = 1       // Station number (Slave ID)
        H05 = 96      // Communication speed (9600 bps)
        H06 = 0       // Stop bit length (1 bit)
        H07 = 2       // No parity

// Đọc tần số đầu ra (Hz)
        [MODRD] [K1] [H0001] [K1] [D100]
        // K1: Slave ID
        // H0001: Register address (tần số đầu ra)
        // K1: Số register đọc
        // D100: Vùng nhớ lưu dữ liệu
         // Đọc dòng tải (A)  
        [MODRD] [K1] [H0002] [K1] [D101]
         // Đọc trạng thái RUN/STOP
        [MODRD] [K1] [H0003] [K1] [D102]
         // Ghi tần số đặt (Hz)
        [MODWR] [K1] [H1001] [K1] [D200]

// Biến tần 1-4: Bơm chính (ID: 1-4)
        // Biến tần 5-8: Bơm phụ (ID: 5-8)
        // Cycle đọc: 500ms (đủ nhanh cho ứng dụng bơm)
         // Logic điều khiển áp suất
        LD    [Pressure < 4bar]
        AND   [VFD1_Status = Ready] 
        OUT   [Start_VFD1]
         // Đọc dòng tải để phát hiện tắc bơm
        LD    [D100 > 150]    // Dòng tải > 15A (×10)
        AND   [Timer_5s]      // Kéo dài 5 giây
        OUT   [Alarm_Pump_Blocked]

Gateway/Router:     192.168.1.1
        PLC/SCADA Server:   192.168.1.10-19  
        HMI/Operator Panel: 192.168.1.20-29
        Biến tần:           192.168.1.100-199
        Thiết bị đo lường:  192.168.1.200-249

Tham số 98.02 = 3    // Fieldbus: Ethernet
        Tham số 98.03 = 2    // Giao thức: Modbus TCP
        Tham số 50.01 = 192.168.1.101  // Địa chỉ IP
        Tham số 50.02 = 255.255.255.0  // Subnet Mask  
        Tham số 50.03 = 192.168.1.1    // Gateway

Loại PPO: PPO1 (2 từ điều khiển + 2 từ giám sát)
        Từ điều khiển:    PPD 1 (40001)
        Tần số tham chiếu: PPD 2 (40002)  
        Từ trạng thái:     PPD 3 (40003)
        Tần số thực tế:    PPD 4 (40004)

// Tạo kết nối trong WinCC
        Tên kết nối: VFD_ModbusTCP
        Driver: "Modbus TCP/IP"
        Địa chỉ IP: 192.168.1.101
        Cổng: 502
        ID đơn vị: 1
         // Mapping biến
        Tần_số_thực_tế:    40004 (REAL)
        Dòng_điện_thực_tế: 40005 (REAL) 
        Từ_trạng_thái:     40003 (WORD)
        Mã_báo_động:       40010 (WORD)
         Tần_số_đặt:        40001 (REAL)
        Từ_điều_khiển:     40002 (WORD)

// C Script trong WinCC để giám sát kết nối
        #include "apdefap.h"
        void KiemTraKetNoiVFD()
        {
            if (GetTagBit("VFD1_Ket_noi") == 0)
            {
                SetTagBit("Bao_dong_VFD1_mat_ket_noi", 1);
                // Gửi email hoặc SMS cảnh báo
                GuiThongBao("VFD1 mất kết nối lúc " + LayThoiGianHeThong());
            }
        }

// Trong TIA Portal V17
        Thiết bị: SINAMICS G120 CU250S-2 PN
        Địa chỉ IP: 192.168.1.120
        Telegram: Standard Telegram 1
          - Từ điều khiển (STW1)
          - Tốc độ đặt  
          - Từ trạng thái (ZSW1)
          - Tốc độ thực tế
         // Chức năng an toàn tích hợp
        Safe Torque Off (STO) được ánh xạ vào I/O an toàn
        Chuỗi dừng khẩn cấp qua ProfiSafe

// Cấu hình phần cứng trong TIA Portal
        Thiết bị: Siemens G120C với CU230P-2 PN
        Tên thiết bị: "VFD_Day_chuyen1_Dong_co1"
        Địa chỉ IP: 192.168.0.120/24
        Thời gian cập nhật: 4ms (Gửi/Nhận)
         // Ánh xạ Process Image
        %IW100: Từ trạng thái (ZSW1)
        %IW102: Tốc độ thực tế
        %IW104: Dòng điện thực tế  
        %IW106: Điện áp bus DC
        %QW100: Từ điều khiển (STW1)
        %QW102: Tốc độ đặt
        %QW104: Thời gian tăng tốc
        %QW106: Thời gian giảm tốc

FUNCTION_BLOCK "FB_Dieu_khien_VFD"
        VAR_INPUT
            Cho_phep : BOOL;
            Toc_do_dat : REAL;  // Hz
            Thoi_gian_tang_toc : REAL; // giây
        END_VAR
         VAR_OUTPUT
            Toc_do_thuc_te : REAL;
            Dong_dien_thuc_te : REAL;
            Trang_thai : WORD;
            Loi : BOOL;
        END_VAR
         // Logic điều khiển chính
        IF Cho_phep AND NOT Loi THEN
            #Tu_dieu_khien.X0 := TRUE;  // Lệnh ON
            #Tu_dieu_khien.X1 := FALSE; // Không OFF1  
            #Tu_dieu_khien.X2 := TRUE;  // Không OFF2
            #Tu_dieu_khien.X3 := TRUE;  // Cho phép vận hành
            
            // Scale tốc độ đặt (0-50Hz = 0-16384)
            #Toc_do_dat_scaled := REAL_TO_INT(Toc_do_dat * 327.68);
        END_IF;

 
        <Slave>   
        	<Info>     
        		<n>VFD_Servo_Truc1</n>     
        		<Id>1001</Id>     
        		<Addr>1001</Addr>   
        	</Info>   
        	<ESC>     
        		<Type>EtherCAT servo drive</Type>     
        		<RxPDO>       
        			<Index>0x1600</Index>       
        			<n>RxPDO-Map</n>       
        			<Entry>         
        				<Index>0x6040</Index> 
        				<SubIndex>0x00</SubIndex>         
        				<BitLen>16</BitLen>       
        			</Entry>       
        			<Entry>         
        				<Index>0x607A</Index>          
        				<SubIndex>0x00</SubIndex>         
        				<BitLen>32</BitLen>       
        			</Entry>     
        		</RxPDO>   
        	</ESC> 
        </Slave>

PROGRAM PLC_PRG
        VAR
            fbMC_Power: MC_Power;
            fbMC_MoveAbsolute: MC_MoveAbsolute;
            Truc1: AXIS_REF;
            bThuc_hien: BOOL;
            fVi_tri: LREAL;
            fToc_do: LREAL := 100.0;
        END_VAR
         // Kích hoạt trục
        fbMC_Power(
            Axis := Truc1,
            Enable := TRUE,
            Enable_Positive := TRUE,
            Enable_Negative := TRUE
        );
         // Định vị tuyệt đối
        IF bThuc_hien THEN
            fbMC_MoveAbsolute(
                Axis := Truc1,
                Execute := TRUE,
                Position := fVi_tri,
                Velocity := fToc_do,
                Acceleration := 500.0,
                Deceleration := 500.0
            );
            
            IF fbMC_MoveAbsolute.Done THEN
                bThuc_hien := FALSE;
            END_IF
        END_IF

DỰ ÁN: [Tên dự án]
        KHÁCH HÀNG: [Tên công ty]
        NGÀY KHẢO SÁT: [Ngày tháng]
         1. HIỆN TRẠNG:
           - Số biến tần: __ (Hãng: __)
           - PLC: __ (Khả năng RS485: __ cổng)
           - Khoảng cách tối đa: __m
           - Nhiễu EMI: [Thấp/Trung bình/Cao]
         2. YÊU CẦU:
           - Giám sát: [Thời gian thực <1s / Gần thời gian thực <10s]
           - Ghi dữ liệu: [Có/Không]
           - Truy cập từ xa: [Có/Không]
           - Ngân sách: [Khoảng]
         3. GIẢI PHÁP ĐỀ XUẤT:
           - Phương pháp: [Modbus RTU/TCP/Profinet]
           - Thiết bị bổ sung: [Danh sách]
           - Thời gian triển khai: [Timeline]
           - Chi phí ước tính: [Giá]

   Khu vực 1 (Sản xuất): ID 1-10
           Khu vực 2 (Phụ trợ): ID 11-20  
           Khu vực 3 (Xử lý): ID 21-30

// Cấu trúc chương trình chính
        ORGANIZATION_BLOCK OB1
            CALL FB_Quan_ly_ModbusRTU;     // Xử lý truyền thông
            CALL FB_Xu_ly_du_lieu_VFD;     // Xử lý dữ liệu thô  
            CALL FB_Quan_ly_bao_dong;      // Xử lý báo động
            CALL FB_Ghi_du_lieu;           // Ghi vào SCADA
        END_ORGANIZATION_BLOCK
         // Xử lý lỗi truyền thông
        ORGANIZATION_BLOCK OB122  // I/O Error
            CALL FC_Xu_ly_loi_truyen_thong;
        END_ORGANIZATION_BLOCK

[Internet] ← VPN Router ← [Core Switch]
                                     ↓
                                [SCADA Server]
                                     ↓
                      ┌─────────────┼─────────────┐
                      ↓             ↓             ↓
                [RS485 Gateway] [Eth Switch] [Profinet Master]
                      ↓             ↓             ↓
                [VFD 1-20]    [VFD 21-35]   [VFD 36-45]

# Python script chạy trên Raspberry Pi 4 
        import modbus_tk.modbus_rtu as modbus_rtu
        import serial
        import mysql.connector
        from datetime import datetime
        class VFDDataCollector:     
        	def __init__(self):         
        		self.master = modbus_rtu.RtuMaster(            serial.Serial(port="/dev/ttyUSB0", baudrate=9600, bytesize=8, 
                                 parity='N', stopbits=1)         
                                )         
                 self.master.set_timeout(1.0) 
                         
            def read_vfd_data(self, slave_id):         
            	try:             
            		# Đọc frequency, current, voltage, status             
            		data = self.master.execute(slave_id, 3, 0, 4) #Function 3, start 0, count 4             
                    
                    frequency = data[0] / 10.0  # Hz             
                    current = data[1] / 10.0    # A               
                    voltage = data[2]           # V             
                    status = data[3]            # Status word             
                    
                    return {                 
                    	'frequency': frequency,                 
                    	'current': current, 
                        'voltage': voltage,                 
                        'status': status,                 
                        'timestamp': datetime.now()             
                        }         
                  except Exception as e:             
                  	print(f"Error reading VFD {slave_id}: {e}")             
                  	return None             
            def store_to_database(self, vfd_id, data):         
            	# Lưu vào MySQL database cho SCADA đọc         
            	conn = mysql.connector.connect(             
            		host='192.168.1.10',             
            		database='factory_data',             
            		user='scada_user',             
            		password='secure_password'         
            		)         
            	cursor = conn.cursor()
            	         
                query = """INSERT INTO vfd_data 
                           (vfd_id, frequency, current, voltage, status, timestamp)
                           VALUES (%s, %s, %s, %s, %s, %s)"""         
                values = (vfd_id, data['frequency'], data['current'], 
                         data['voltage'], data['status'], data['timestamp'])         
                cursor.execute(query, values)         
                conn.commit()         
                cursor.close()         
                conn.close()  
        # Main collecting loop 
        collector = VFDDataCollector() 
        while True:     
        	for vfd_id in range(1, 21):  # VFD ID 1-20         
        		data = collector.read_vfd_data(vfd_id)         
        		if data:             
        			collector.store_to_database(vfd_id, data)     
        		time.sleep(5)  # Poll every 5 seconds

-- Database connection in WinCC 
        CREATE VIEW v_vfd_realtime AS 
        SELECT 
            vfd_id,     
            frequency,     
            current,     
            voltage,     
            CASE 
                WHEN status & 1 = 1 THEN 'RUN' 
                ELSE 'STOP' 
            END as run_status,     
            CASE 
                WHEN current < 0.5 AND frequency > 0 THEN 'NO_LOAD'         
                WHEN current > 15 THEN 'OVERLOAD'         
                ELSE 'NORMAL'     
            END as load_status,     
            timestamp 
        FROM vfd_data 
        WHERE timestamp > DATE_SUB(NOW(), INTERVAL 1 MINUTE);  
        -- Efficiency calculation 
        CREATE VIEW v_efficiency_report AS 
        SELECT 
            DATE(timestamp) as date,     
            vfd_id,     
            AVG(frequency) as avg_frequency,     
            AVG(current) as avg_current,     
            SUM(CASE WHEN current > 0.5 THEN 1 ELSE 0 END) * 5 / 60 as running_minutes,     	
            COUNT(*) * 5 / 60 as total_minutes
        FROM vfd_data
        GROUP BY DATE(timestamp), vfd_id;

// ST Code cho S7-1500
        FUNCTION_BLOCK FB_ModbusHealthMonitor
        VAR_INPUT
            Enable : BOOL;
            VFD_SlaveID : INT;
        END_VAR
        VAR_OUTPUT  
            CommStatus : BOOL;
            ErrorCount : INT;
            LastErrorTime : DATE_AND_TIME;
        END_VAR
        VAR
            CommTimer : TON;
            LastGoodComm : DATE_AND_TIME;
            ConsecutiveErrors : INT;
        END_VAR
         // Monitor communication
        IF Enable THEN
            // Check if data is updating
            CommTimer(IN := CommStatus, PT := T#10s);
            
            IF CommTimer.Q THEN  // No comm for 10 seconds
                ConsecutiveErrors := ConsecutiveErrors + 1;
                LastErrorTime := SYSTEM_DATETIME();
                
                // Auto recovery attempt
                IF ConsecutiveErrors >= 3 THEN
                    // Reset communication module
                    "MB_COMM_LOAD"(REQ := TRUE, ID := 1);
                    ConsecutiveErrors := 0;
                END_IF;
            ELSE
                LastGoodComm := SYSTEM_DATETIME();
                ConsecutiveErrors := 0;
            END_IF;
        END_IF;

# Python script để verify data scaling 
        import struct
        import modbus_tk.modbus_rtu as modbus_rtu
        def check_vfd_scaling(slave_id, register_addr):     
        	"""
            Kiểm tra scaling factor của biến tần
            """     
            master = modbus_rtu.RtuMaster(serial.Serial('/dev/ttyUSB0', 9600))     
            
            # Đọc raw data     
            raw_data = master.execute(slave_id, 3, register_addr, 1)[0]     
            print(f"Raw register value: {raw_data}")     
            
            # Test các scaling factor phổ biến     
            scaling_factors = [1, 10, 100, 327.67, 655.35]
                 
            for factor in scaling_factors:         
            	scaled_value = raw_data / factor
                print(f"Scaling by {factor}: {scaled_value:.2f} Hz")         
                
                # So sánh với giá trị thực tế đo được         
                if 45 <= scaled_value <= 55:  # Giả sử tần số thực tế khoảng 50Hz             
                	print(f"✓ Likely scaling factor: {factor}")             
                	return factor
            
            return None  
        # Usage 
        correct_scaling = check_vfd_scaling(slave_id=1, register_addr=1)

# Capture Modbus TCP traffic 
        sudo tcpdump -i eth0 -w modbus_capture.pcap port 502  
        # Analyze với tshark tshark 
        -r modbus_capture.pcap -Y "modbus" -T fields \     
        	-e ip.src -e ip.dst -e modbus.func_code -e modbus.trans_id

// Optimized polling strategy in SCADA
        FUNCTION_BLOCK FB_OptimizedPolling
        VAR_INPUT
            Enable : BOOL;
        END_VAR
        VAR
            FastCycle : TON;    // 1s cycle for critical data
            MediumCycle : TON;  // 10s cycle for important data  
            SlowCycle : TON;    // 60s cycle for monitoring data
            
            FastPollTrigger : BOOL;
            MediumPollTrigger : BOOL; 
            SlowPollTrigger : BOOL;
        END_VAR
         // Fast cycle - Critical data
        FastCycle(IN := NOT FastPollTrigger, PT := T#1s);
        FastPollTrigger := FastCycle.Q;
         IF FastPollTrigger THEN
            // Read status words from all VFDs
            FOR i := 1 TO 20 DO
                CALL MB_CLIENT(
                    REQ := TRUE,
                    ID := 1,
                    SLAVE := i,
                    FUNC := 3,
                    ADDR := 40003,  // Status word
                    LEN := 1,
                    DATA_PTR := ADR(VFD[i].StatusWord)
                );
            END_FOR;
        END_IF;
         // Medium cycle - Process data
        MediumCycle(IN := NOT MediumPollTrigger, PT := T#10s);
        MediumPollTrigger := MediumCycle.Q;
         IF MediumPollTrigger THEN
            // Read frequency, current, voltage
            FOR i := 1 TO 20 DO
                CALL MB_CLIENT(
                    REQ := TRUE,
                    ID := 1, 
                    SLAVE := i,
                    FUNC := 3,
                    ADDR := 40001,  // Freq, Current, Voltage
                    LEN := 3,
                    DATA_PTR := ADR(VFD[i].ProcessData)
                );
            END_FOR;
        END_IF;

-- Stored procedure tạo báo cáo hàng ngày 
        DELIMITER // 
        CREATE PROCEDURE GenerateDailyReport(IN report_date DATE) 
        BEGIN     
        	DECLARE done INT DEFAULT FALSE;     
        	DECLARE vfd_id INT;     
        	DECLARE vfd_cursor CURSOR FOR 
                SELECT DISTINCT vfd_id FROM vfd_data WHERE DATE(timestamp) = report_date;     	
            DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;      
            -- Create temporary report table     
            CREATE TEMPORARY TABLE IF NOT EXISTS daily_report (         
            	vfd_id INT,         
            	avg_frequency DECIMAL(5,2),         
            	avg_current DECIMAL(5,2),         
            	max_current DECIMAL(5,2),         
            	running_hours DECIMAL(5,2),         
            	energy_consumed DECIMAL(8,2),         
            	efficiency_percent DECIMAL(5,2),         
            	alarm_count INT,         
            	availability_percent DECIMAL(5,2)     
            	);      
            -- Process each VFD     
            OPEN vfd_cursor;     
            read_loop: LOOP         
            	FETCH vfd_cursor INTO vfd_id;         
            	IF done THEN             
            		LEAVE read_loop;         
            	END_IF;         
                INSERT INTO daily_report
                SELECT 
                    vfd_id,             
                    AVG(frequency) as avg_frequency,             
                    AVG(current) as avg_current,             
                    MAX(current) as max_current,             
                    SUM(CASE WHEN status & 1 = 1 THEN 5.0/60 ELSE 0 END) as running_hours,             
                    SUM(voltage * current * 1.732 / 1000 * 5.0/60) as energy_consumed,             
                    AVG(CASE WHEN current > 0.5 THEN (frequency/50) * 100 ELSE 0 END) as efficiency_percent,             
                    SUM(CASE WHEN status & 0xFFFE > 0 THEN 1 ELSE 0 END) as alarm_count,             
                    (SUM(CASE WHEN status & 1 = 1 THEN 1 ELSE 0 END) * 100.0 / COUNT(*)) as availability_percent
                FROM vfd_data 
                WHERE DATE(timestamp) = report_date AND vfd_data.vfd_id = vfd_id;         
            END LOOP;    
            CLOSE vfd_cursor;     
            
            -- Generate summary     
            SELECT 
                'DAILY PRODUCTION REPORT' as title,         
                report_date as date,         
                COUNT(*) as total_vfds,         
                AVG(availability_percent) as overall_availability,         
                SUM(energy_consumed) as total_energy_kwh,         
                SUM(alarm_count) as total_alarms
            FROM daily_report;     
            
            -- Detail by VFD     
            SELECT * FROM daily_report ORDER BY vfd_id;     
            
            DROP TEMPORARY TABLE daily_report; 
        END // 
        DELIMITER ;  
        -- Schedule to run every day at 6 AM 
        CREATE EVENT DailyReportEvent
        ON SCHEDULE EVERY 1 DAY 
        STARTS CURRENT_DATE + INTERVAL 6 HOUR 
        DO CALL GenerateDailyReport(CURDATE() - INTERVAL 1 DAY);