碰焊机器人PLC程序(贝加莱B&R)

最新推荐文章于 2024-10-28 19:27:34 发布
最新推荐文章于 2024-10-28 19:27:34 发布
阅读量1.4k 收藏 2
点赞数 1
分类专栏： PLC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xdpcxq/article/details/128505819
版权

机器人控制 CRC校验 上位机通信 状态反馈 操作命令
关键词由优快云通过智能技术生成

(********************************************************************
 * COPYRIGHT
 ********************************************************************
 * Program: MotionTask
 * File: UserPostAction.st
 * Author: chen
 * Created: April 07, 2022
 ********************************************************************
 * Implementation of program MotionTask
 ********************************************************************)

(* Add a new action to your IEC program or library *)
ACTION UserPostAction:
    
    (******************接收数据，格式参见相关协议*************************)
    (***********************解析上位机操作命令****************************)
    IF Recv_0.Data[0] = 1 THEN        //地址信息
        (**************************CRC校验*********************)
        Recv_0.CRC := SHL(BYTE_TO_UINT(Recv_0.Data[Recv_0.Recvlen-1]),8) + BYTE_TO_UINT(Recv_0.Data[Recv_0.Recvlen-2]);
        CRC_0.buffer := Recv_0.Data;
        CRC_0.length := Recv_0.Recvlen - 2;
        CRC_0.polynom := 16#A001;
        CRC_0.enable := TRUE;
        CRC_0();
        IF CRC_0.done THEN
            IF Recv_0.CRC = CRC_0.uiCRC THEN    //33803      1 3 0 0 0 1 132  10
                CASE BYTE_TO_INT(Recv_0.Data[1]) OF
                    (*功能码03：接收控制指令*)        
                    03:        
                        Recv_0.InstructID := SHL(BYTE_TO_UINT(Recv_0.Data[2]),8) + BYTE_TO_UINT(Recv_0.Data[3]);
                        Recv_0.InstructNum := SHL(BYTE_TO_UINT(Recv_0.Data[4]),8) + BYTE_TO_UINT(Recv_0.Data[5]);
                    
                    (*功能码16：接收多个数据*)
                    16:
                        Recv_0.PramNum := SHL(BYTE_TO_UINT(Recv_0.Data[4]),8) + BYTE_TO_UINT(Recv_0.Data[5]);    (*指令数*)
                        memcpy(ADR(Recv_0.Prameter),ADR(Recv_0.Data[7]),Recv_0.PramNum*2);                        (*指令内容*)
                        Recv_0.PramID[0] := SHR(BYTE_TO_UINT(Recv_0.Data[2]),8) + BYTE_TO_UINT(Recv_0.Data[3])+1;    (*指令首地址*)
                        FOR i := 0 TO Recv_0.PramNum-1 DO    
                            Recv_0.PramID[i] := Recv_0.PramID[0] + i;
                            CASE Recv_0.PramID[i] OF
                                16#01:
                                //UpperCommd_0.RobotState := LOAD;
                                IF Recv_0.Prameter[1]=1 THEN
                                    UpperCommd_0.RobotState := AUTHOR;
                                ELSE UpperCommd_0.RobotState := DISABLE;
                                END_IF
                                16#02:
                                UpperCommd_0.RobotState := START;
                                16#03:
                                UpperCommd_0.RobotState := INTERRUPT;
                                16#04:
                                UpperCommd_0.RobotState := ESTOP;
                                16#05:
                                UpperCommd_0.Startflag := TRUE;
                                16#06:
                                UpperCommd_0.RobotState := CLEAR;
                                16#14:
                                UpperCommd_0.RobotState := START;
                                UpperCommd_0.Startflag := TRUE;
                                16#15:
                                FeederDelivery_0.TypeInSlot[1] := BYTE_TO_UINT(Recv_0.Prameter[2]);
                                16#16:
                                FeederDelivery_0.TypeInSlot[2] := BYTE_TO_UINT(Recv_0.Prameter[4]);
                                16#17:
                                FeederDelivery_0.TypeInSlot[3] := BYTE_TO_UINT(Recv_0.Prameter[6]);
                                16#18:
                                FeederDelivery_0.TypeInSlot[4] := BYTE_TO_UINT(Recv_0.Prameter[8]);
                                16#19:
                                FeederDelivery_0.TypeInSlot[5] := BYTE_TO_UINT(Recv_0.Prameter[10]);
                                16#1A:
                                FeederDelivery_0.TypeInSlot[6] := BYTE_TO_UINT(Recv_0.Prameter[12]);
                                16#1B:
                                FeederDelivery_0.TypeInSlot[7] := BYTE_TO_UINT(Recv_0.Prameter[14]);
                                16#1C:
                                FeederDelivery_0.TypeInSlot[8] := BYTE_TO_UINT(Recv_0.Prameter[16]);
                                16#1D:
                                FeederDelivery_0.TypeInSlot[9] := BYTE_TO_UINT(Recv_0.Prameter[18]);
                                16#1E:
                                FeederDelivery_0.TypeInSlot[10] := BYTE_TO_UINT(Recv_0.Prameter[20]);
                            END_CASE
                        END_FOR
                END_CASE                
            END_IF
        END_IF
    END_IF


    (********************获取当前机器人状态**************************)
    Step_Robot_GroupReadStatus_0.Enable := TRUE;
    Step_Robot_GroupReadStatus_0.AxesGroup := 0;//ADR(robot);
    Step_Robot_GroupReadStatus_0();
    IF Step_Robot_GroupReadStatus_0.Error = TRUE THEN
        Error :=Step_Robot_GroupReadStatus_0.ErrorID;
    ELSE
        IF Step_Robot_GroupReadStatus_0.GroupErrorStop THEN
            RobotStatus_0.RunStatus := ErrorStop;
        ELSIF Step_Robot_GroupReadStatus_0.GroupPower THEN
            RobotStatus_0.RunStatus := Power;
        ELSIF Step_Robot_GroupReadStatus_0.GroupRunning THEN
            RobotStatus_0.RunStatus := Running;
        ELSIF Step_Robot_GroupReadStatus_0.GroupStandby THEN
            RobotStatus_0.RunStatus := Standby;
        ELSIF Step_Robot_GroupReadStatus_0.GroupRunning_Interrupt THEN
            RobotStatus_0.RunStatus := Running_Interrupt;
        ELSIF Step_Robot_GroupReadStatus_0.GroupRunning_Moving THEN
            RobotStatus_0.RunStatus := Running;
        ELSIF Step_Robot_GroupReadStatus_0.GroupRunning_Repo THEN
            RobotStatus_0.RunStatus := Running;
        ELSIF Step_Robot_GroupReadStatus_0.GroupRunning_Jogging THEN
            RobotStatus_0.RunStatus := Running;
        END_IF
    END_IF
    Step_Robot_GroupReadStatus_0.Enable := FALSE;
    
    (*********************获取机器人操作模式***************************)
    Step_Robot_GetOperationMode_0.Enable := 1;
    Step_Robot_GetOperationMode_0();
    IF Step_Robot_GetOperationMode_0.ManualT1 THEN
        RobotStatus_0.RobotMode := Manual;
    ELSIF Step_Robot_GetOperationMode_0.ManualT2 THEN
        RobotStatus_0.RobotMode := Manual;
    ELSIF Step_Robot_GetOperationMode_0.Auto THEN
        RobotStatus_0.RobotMode := Auto;
    ELSIF Step_Robot_GetOperationMode_0.AutoExternal THEN
        RobotStatus_0.RobotMode := AutoExternal;
    END_IF
    Step_Robot_GetOperationMode_0.Enable := 0;
    (*********************************读取示教器数据**************************)
    GetBOOLFromHMI_0(Enable := 1, PortNumber := 1);
    bool1 := GetBOOLFromHMI_0.Data;
    GetBOOLFromHMI_0(Enable := 1, PortNumber := 2);
    bool2 := GetBOOLFromHMI_0.Data;
    GetBOOLFromHMI_0(Enable := 1, PortNumber := 3);
    bool3 := GetBOOLFromHMI_0.Data;
    GetBOOLFromHMI_0(Enable := 1, PortNumber := 4);
    bool4 := GetBOOLFromHMI_0.Data;
    GetBOOLFromHMI_0(Enable := 1, PortNumber := 5);
    bool5 := GetBOOLFromHMI_0.Data;
    GetBOOLFromHMI_0(Enable := 1, PortNumber := 6);
    bool6 := GetBOOLFromHMI_0.Data;
    GetBOOLFromHMI_0(Enable := 1, PortNumber := 7);
    bool7 := GetBOOLFromHMI_0.Data;
    GetBOOLFromHMI_0(Enable := 1, PortNumber := 8);
    bool8 := GetBOOLFromHMI_0.Data;
    GetBOOLFromHMI_0(Enable := 1, PortNumber := 9);
    bool9 := GetBOOLFromHMI_0.Data;
    GetBOOLFromHMI_0(Enable := 1, PortNumber := 10);
    bool10 := GetBOOLFromHMI_0.Data;
    //GetBOOLFromHMI_0(Enable := 1, PortNumber := 2, data=>bool2);
    
    
    (*********************响应上位机操作命令**************************)    
    CASE UpperCommd_0.RobotState OF
        WAIT:(**)
            (*
            Step_Robot_LoadPath_0.ProjectName := 'Project';
            Step_Robot_LoadPath_0.ProgramName := 'Program';
            Step_Robot_LoadPath_0.AxesGroup := ADR(robot);
            Step_Robot_LoadPath_0.Execute := TRUE;
            Step_Robot_LoadPath_0();
            IF Step_Robot_LoadPath_0.Done = TRUE THEN
                RobotStatus_0.ProgramLoad := TRUE;
            ELSE
                RobotStatus_0.ProgramLoad := FALSE;
                Error := 16#11;//加载程序失败：请检查程序名称。
            END_IF
        *)
            ;
        AUTHOR:(*获取权限*)
            IF RobotStatus_0.GetAuthor = FALSE THEN
                IF RobotStatus_0.RobotMode = AutoExternal THEN
                    Step_Robot_ReqCtrlAuth_0.Execute := TRUE;
                    Step_Robot_ReqCtrlAuth_0.RequestAuthority := TRUE;    
                    Step_Robot_ReqCtrlAuth_0();
                    IF Step_Robot_ReqCtrlAuth_0.Status THEN
                        RobotStatus_0.GetAuthor := Step_Robot_ReqCtrlAuth_0.Status;
                        icont := icont + 1;
                        //UpperCommd_0.RobotState := LOAD;
                    END_IF
                ELSE
                    Error := 1;    //模式错误
                END_IF
            ELSE
                UpperCommd_0.RobotState := LOAD;
            END_IF
            Step_Robot_ReqCtrlAuth_0.Execute := FALSE;
            Step_Robot_ReqCtrlAuth_0();
        LOAD:    (*加载程序*)
            IF RobotStatus_0.GetAuthor = TRUE THEN                        
                Step_Robot_LoadPath_0.ProjectName := 'test';
                Step_Robot_LoadPath_0.ProgramName := 'test1';
                Step_Robot_LoadPath_0.AxesGroup := 0;//ADR(robot);
                Step_Robot_LoadPath_0.Execute := TRUE;
                Step_Robot_LoadPath_0();
            (*
                IF Step_Robot_LoadPath_0.Done = TRUE THEN
                    RobotStatus_0.ProgramLoad := TRUE;
                ELSE
                    RobotStatus_0.ProgramLoad := FALSE;
                    Error := 21;//加载程序失败：请检查程序名称。
                    UpperCommd_0.RobotState := WAIT;
                END_IF
                
                *)
                RobotStatus_0.ProgramLoad := TRUE;
                UpperCommd_0.RobotState := ENABLE;
            END_IF
            Step_Robot_LoadPath_0.Execute := FALSE;
            Step_Robot_LoadPath_0();
        ENABLE:(*使能*)
            IF (RobotStatus_0.RunStatus <> Power) OR (RobotStatus_0.RunStatus <> Running) OR (RobotStatus_0.RunStatus <> Running_Interrupt) THEN
                IF RobotStatus_0.GetAuthor = TRUE THEN                                                    
                    IF RobotStatus_0.ProgramLoad = TRUE THEN
                        GroupPower_0.Enable := 1;
                        GroupPower_0();
                        UpperCommd_0.RobotState := WAIT;
                    ELSE
                        Error := 23;//未加载程序。
                        UpperCommd_0.RobotState := WAIT;
                    END_IF
                ELSE
                    UpperCommd_0.RobotState := WAIT;//
                    Error := 20;//无权限
                END_IF
            ELSE
                UpperCommd_0.RobotState := WAIT;
            END_IF
        //    GroupPower_0.Enable := 0;
        START:(*启动命令*)
            IF (RobotStatus_0.RunStatus = Power) OR (RobotStatus_0.RunStatus = Running_Interrupt)THEN
                Step_Robot_StartPath_0.AxesGroup := 0;//ADR(robot);
                Step_Robot_StartPath_0.Enable := 1;
                Step_Robot_StartPath_0();
            ELSE
                Error :=31;    //启动失败：没有使能
                UpperCommd_0.RobotState := WAIT;
            END_IF
            UpperCommd_0.RobotState := WAIT;
            //Step_Robot_StartPath_0.Enable := 0;
        INTERRUPT:(*运动暂停命令*)
            IF (RobotStatus_0.RunStatus = Running) OR (RobotStatus_0.RunStatus = Running_Moving) OR (RobotStatus_0.RunStatus = Running_Interrupt) THEN
                Step_Robot_InterruptPath_0.AxesGroup := 0;//ADR(robot);
                Step_Robot_InterruptPath_0.Execute := TRUE;
                Step_Robot_InterruptPath_0();
                IF Step_Robot_InterruptPath_0.Done = FALSE THEN
                    Error := 41;//中断操作失败。
                    UpperCommd_0.RobotState := WAIT;
                END_IF
            ELSE
                tips :=3;    //机器人未运动。
                UpperCommd_0.RobotState := WAIT;
            END_IF
            UpperCommd_0.RobotState := WAIT;
            Step_Robot_InterruptPath_0.Execute := FALSE;
            Step_Robot_InterruptPath_0();
        CLEAR:(*清除错误*)
            Error := 0;
            
            ConfirmAllMsg.Execute := TRUE;
            ConfirmAllMsg.AxesGroup := 0;
            ConfirmAllMsg();
            UpperCommd_0.RobotState := WAIT;
            ConfirmAllMsg.Execute := FALSE;
            ConfirmAllMsg();
        //    )
        ERROR:(*上位机出错，停止运动*)
    END_CASE
        
    (******************************发送状态赋值***************************************)
    (*状态反馈*)
    CASE RobotStatus_0.RunStatus OF
        Power:            
            Send_0.RobotState := 16#01;
        Running:
            Send_0.RobotState := 16#02;
        Standby:
            Send_0.RobotState := 16#03;
        ErrorStop:
            Send_0.RobotState := 16#04;
        Running_Interrupt:
            Send_0.RobotState := 16#05;
        Running_Moving:
            Send_0.RobotState := 16#06;
        Running_Repo:
            Send_0.RobotState := 16#07;
        Running_Jog:
            Send_0.RobotState := 16#08;
    END_CASE
    (*工作流程反馈*)
    //Send_0.WorkState := 正在取工件的槽<<8 + 剩余工件数量。
    
    
    (********************************给示教器的信息*******************************)    
    IF UpperCommd_0.Startflag = TRUE THEN
        RobotDI[21] := 1;
    ELSE
        RobotDI[21] := 0;
    END_IF
    
    IF bool1=1 OR bool2=1 OR bool3=1 OR bool4=1 OR bool5=1 OR bool6=1 OR bool7=1 OR bool8=1 OR bool8=1 OR bool10=1 THEN
        UpperCommd_0.Startflag := FALSE;
    END_IF    
    (*外部点*)
    //IF Recv_0.Data[1] = 1 THEN
    //    SetRobotCartPos_0.Enable := 1;
    //    SetRobotCartPos_0.PortNumber := 0;
    //    SetRobotCartPos_0.RobotCartPos := CartPos[0];
    //    SetRobotCartPos_0();
    //END_IF
    
    (*Slot1*)
    IF FeederDelivery_0.TypeInSlot[1] = 0 THEN
        SlotBool1 := TRUE;
    ELSIF FeederDelivery_0.TypeInSlot[1] = 1 THEN
        SlotBool1 := FALSE;
        SlotBool2 := TRUE;
    ELSIF FeederDelivery_0.TypeInSlot[1] = 2 THEN
        SlotBool1 := FALSE;
        SlotBool2 := FALSE;
    END_IF

    SetBOOLToHMI_1.Data := SlotBool1;
    SetBOOLToHMI_1.Enable := 1;
    SetBOOLToHMI_1.PortNumber := 11;
    SetBOOLToHMI_1();
    
    SetBOOLToHMI_2.Data := SlotBool2;
    SetBOOLToHMI_2.Enable := 1;
    SetBOOLToHMI_2.PortNumber := 12;
    SetBOOLToHMI_2();
    
    (*Slot2*)
    IF FeederDelivery_0.TypeInSlot[2] = 0 THEN
        SlotBool3 := TRUE;
    ELSIF FeederDelivery_0.TypeInSlot[2] = 1 THEN
        SlotBool3 := FALSE;
        SlotBool4 := TRUE;
    ELSIF FeederDelivery_0.TypeInSlot[2] = 2 THEN
        SlotBool3 := FALSE;
        SlotBool4 := FALSE;
    END_IF

    SetBOOLToHMI_3.Data := SlotBool3;
    SetBOOLToHMI_3.Enable := 1;
    SetBOOLToHMI_3.PortNumber := 13;
    SetBOOLToHMI_3();
    
    SetBOOLToHMI_4.Data := SlotBool4;
    SetBOOLToHMI_4.Enable := 1;
    SetBOOLToHMI_4.PortNumber := 14;
    SetBOOLToHMI_4();
    
    (*Slot3*)
    IF FeederDelivery_0.TypeInSlot[3] = 0 THEN
        SlotBool5 := TRUE;
    ELSIF FeederDelivery_0.TypeInSlot[3] = 1 THEN
        SlotBool5 := FALSE;
        SlotBool6 := TRUE;
    ELSIF FeederDelivery_0.TypeInSlot[3] = 2 THEN
        SlotBool5 := FALSE;
        SlotBool6 := FALSE;
    END_IF

    SetBOOLToHMI_5.Data := SlotBool5;
    SetBOOLToHMI_5.Enable := 1;
    SetBOOLToHMI_5.PortNumber := 15;
    SetBOOLToHMI_5();
    
    SetBOOLToHMI_6.Data := SlotBool6;
    SetBOOLToHMI_6.Enable := 1;
    SetBOOLToHMI_6.PortNumber := 16;
    SetBOOLToHMI_6();
    
    (*Slot4*)
    IF FeederDelivery_0.TypeInSlot[4] = 0 THEN
        SlotBool7 := TRUE;
    ELSIF FeederDelivery_0.TypeInSlot[4] = 1 THEN
        SlotBool7 := FALSE;
        SlotBool8 := TRUE;
    ELSIF FeederDelivery_0.TypeInSlot[4] = 2 THEN
        SlotBool7 := FALSE;
        SlotBool8 := FALSE;
    END_IF

    SetBOOLToHMI_7.Data := SlotBool7;
    SetBOOLToHMI_7.Enable := 1;
    SetBOOLToHMI_7.PortNumber := 17;
    SetBOOLToHMI_7();
    
    SetBOOLToHMI_8.Data := SlotBool8;
    SetBOOLToHMI_8.Enable := 1;
    SetBOOLToHMI_8.PortNumber := 18;
    SetBOOLToHMI_8();
    
    (*Slot5*)
    IF FeederDelivery_0.TypeInSlot[5] = 0 THEN
        SlotBool9 := TRUE;
    ELSIF FeederDelivery_0.TypeInSlot[5] = 1 THEN
        SlotBool9 := FALSE;
        SlotBool10 := TRUE;
    ELSIF FeederDelivery_0.TypeInSlot[5] = 2 THEN
        SlotBool9 := FALSE;
        SlotBool10 := FALSE;
    END_IF

    SetBOOLToHMI_9.Data := SlotBool9;
    SetBOOLToHMI_9.Enable := 1;
    SetBOOLToHMI_9.PortNumber := 19;
    SetBOOLToHMI_9();
    
    SetBOOLToHMI_10.Data := SlotBool10;
    SetBOOLToHMI_10.Enable := 1;
    SetBOOLToHMI_10.PortNumber := 20;
    SetBOOLToHMI_10();
    
    (*Slot6*)
    IF FeederDelivery_0.TypeInSlot[6] = 0 THEN
        SlotBool11 := TRUE;
    ELSIF FeederDelivery_0.TypeInSlot[6] = 1 THEN
        SlotBool11 := FALSE;
        SlotBool12 := TRUE;
    ELSIF FeederDelivery_0.TypeInSlot[6] = 2 THEN
        SlotBool11 := FALSE;
        SlotBool12 := FALSE;
    END_IF

    SetBOOLToHMI_11.Data := SlotBool11;
    SetBOOLToHMI_11.Enable := 1;
    SetBOOLToHMI_11.PortNumber := 21;
    SetBOOLToHMI_11();
    
    SetBOOLToHMI_12.Data := SlotBool12;
    SetBOOLToHMI_12.Enable := 1;
    SetBOOLToHMI_12.PortNumber := 22;
    SetBOOLToHMI_12();
    
    (*Slot7*)
    IF FeederDelivery_0.TypeInSlot[7] = 0 THEN
        SlotBool13 := TRUE;
    ELSIF FeederDelivery_0.TypeInSlot[7] = 1 THEN
        SlotBool13 := FALSE;
        SlotBool14 := TRUE;
    ELSIF FeederDelivery_0.TypeInSlot[7] = 2 THEN
        SlotBool13 := FALSE;
        SlotBool14 := FALSE;
    END_IF

    SetBOOLToHMI_13.Data := SlotBool13;
    SetBOOLToHMI_13.Enable := 1;
    SetBOOLToHMI_13.PortNumber := 23;
    SetBOOLToHMI_13();
    
    SetBOOLToHMI_14.Data := SlotBool14;
    SetBOOLToHMI_14.Enable := 1;
    SetBOOLToHMI_14.PortNumber := 24;
    SetBOOLToHMI_14();
    
    (*Slot8*)
    IF FeederDelivery_0.TypeInSlot[8] = 0 THEN
        SlotBool15 := TRUE;
    ELSIF FeederDelivery_0.TypeInSlot[8] = 1 THEN
        SlotBool15 := FALSE;
        SlotBool16 := TRUE;
    ELSIF FeederDelivery_0.TypeInSlot[8] = 2 THEN
        SlotBool15 := FALSE;
        SlotBool16 := FALSE;
    END_IF

    SetBOOLToHMI_15.Data := SlotBool15;
    SetBOOLToHMI_15.Enable := 1;
    SetBOOLToHMI_15.PortNumber := 25;
    SetBOOLToHMI_15();
    
    SetBOOLToHMI_16.Data := SlotBool16;
    SetBOOLToHMI_16.Enable := 1;
    SetBOOLToHMI_16.PortNumber := 26;
    SetBOOLToHMI_16();
    
    (*Slot9*)
    IF FeederDelivery_0.TypeInSlot[9] = 0 THEN
        SlotBool17 := TRUE;
    ELSIF FeederDelivery_0.TypeInSlot[9] = 1 THEN
        SlotBool17 := FALSE;
        SlotBool18 := TRUE;
    ELSIF FeederDelivery_0.TypeInSlot[9] = 2 THEN
        SlotBool17 := FALSE;
        SlotBool18 := FALSE;
    END_IF

    SetBOOLToHMI_17.Data := SlotBool17;
    SetBOOLToHMI_17.Enable := 1;
    SetBOOLToHMI_17.PortNumber := 27;
    SetBOOLToHMI_17();
    
    SetBOOLToHMI_18.Data := SlotBool18;
    SetBOOLToHMI_18.Enable := 1;
    SetBOOLToHMI_18.PortNumber := 28;
    SetBOOLToHMI_18();
    
    (*Slot10*)
    IF FeederDelivery_0.TypeInSlot[10] = 0 THEN
        SlotBool19 := TRUE;
    ELSIF FeederDelivery_0.TypeInSlot[10] = 1 THEN
        SlotBool19 := FALSE;
        SlotBool20 := TRUE;
    ELSIF FeederDelivery_0.TypeInSlot[10] = 2 THEN
        SlotBool19 := FALSE;
        SlotBool20 := FALSE;
    END_IF

    SetBOOLToHMI_19.Data := SlotBool19;
    SetBOOLToHMI_19.Enable := 1;
    SetBOOLToHMI_19.PortNumber := 29;
    SetBOOLToHMI_19();
    
    SetBOOLToHMI_20.Data := SlotBool20;
    SetBOOLToHMI_20.Enable := 1;
    SetBOOLToHMI_20.PortNumber := 30;
    SetBOOLToHMI_20();
    
    
    (*************************发送数据,格式参见相关协议，给触屏*******************************)
    //    Send_0.Data[0] := 1;
    CASE BYTE_TO_INT(Recv_0.Data[1]) OF
        03:
            Send_0.Data[0] := 1;
            Send_0.Data[1] := 3;
            Send_0.Data[2] := UINT_TO_BYTE(Recv_0.InstructNum * 2);
            //Send_0.Data[3] := UINT_TO_BYTE(SHR(Send_0.RobotState,8));
            //Send_0.Data[4] := UINT_TO_BYTE(Send_0.RobotState);
            
            IF RobotStatus_0.RunStatus=Power THEN
                Send_0.Data[3]:= 0;
                Send_0.Data[4]:= 1;
            ELSIF RobotStatus_0.RunStatus=Running THEN
                Send_0.Data[3]:= 0;
                Send_0.Data[4]:= 2;
            ELSIF RobotStatus_0.RunStatus=Standby THEN
                Send_0.Data[3]:= 0;
                Send_0.Data[4]:= 3;
            ELSIF RobotStatus_0.RunStatus=ErrorStop THEN
                Send_0.Data[3]:= 0;
                Send_0.Data[4]:= 4;        
            ELSIF RobotStatus_0.RunStatus=Running_Interrupt THEN
                Send_0.Data[3]:= 0;
                Send_0.Data[4]:= 4;
            END_IF
    
            
            //Send_0.Data[5] := UINT_TO_BYTE(SHR(Send_0.WorkState,8));
            //Send_0.Data[6] := UINT_TO_BYTE(Send_0.WorkState);
            Send_0.Data[5]:=0;
            IF bool1=1 THEN
                Send_0.Data[6]:=1;
            ELSIF  bool2=1 THEN
                Send_0.Data[6]:=2;
            ELSIF  bool3=1 THEN
                Send_0.Data[6]:=3;
            ELSIF  bool4=1 THEN
                Send_0.Data[6]:=4;
            ELSIF  bool5=1 THEN
                Send_0.Data[6]:=5;
            ELSIF  bool6=1 THEN
                Send_0.Data[6]:=6;
            ELSIF  bool7=1 THEN
                Send_0.Data[6]:=7;
            ELSIF  bool8=1 THEN
                Send_0.Data[6]:=8;
            ELSIF  bool9=1 THEN
                Send_0.Data[6]:=9;
            ELSIF  bool10=1 THEN
                Send_0.Data[6]:=10;
            ELSE Send_0.Data[6]:=0;
            END_IF    
                
            //memcpy(ADR(Send_0.Data[7]),ADR(Send_0.RemainParts[0]),10);
            (*CRC校验*)
            CRC_0.buffer := Send_0.Data;
            CRC_0.length := 9 - 2;
            CRC_0.polynom := 16#A001;
            CRC_0.enable := TRUE;
            CRC_0();
            Send_0.Data[7] := UINT_TO_BYTE(CRC_0.uiCRC);
            Send_0.Data[8] := UINT_TO_BYTE(SHR(CRC_0.uiCRC,8));    
            (*memcpy(ADR(Send_0.Data[7]),ADR(Send_0.RemainParts[0]),10);
            //CRC校验
            CRC_0.buffer := Send_0.Data;
            CRC_0.length := 29 - 2;
            CRC_0.polynom := 16#A001;
            CRC_0.enable := TRUE;
            CRC_0();
            Send_0.Data[27] := UINT_TO_BYTE(SHR(CRC_0.uiCRC,8));
            Send_0.Data[28] := UINT_TO_BYTE(CRC_0.uiCRC);*)            
        16:
            Send_0.Data[0] := 1;
            Send_0.Data[1] := 16;
            Send_0.Data[2] := Recv_0.Data[2];
            Send_0.Data[3] := Recv_0.Data[3];
            Send_0.Data[4] := Recv_0.Data[4];
            Send_0.Data[5] := Recv_0.Data[5];
            (*CRC校验*)
            CRC_0.buffer := Send_0.Data;
            CRC_0.length := 8-2;
            CRC_0.polynom := 16#A001;
            CRC_0.enable := TRUE;
            CRC_0();
            Send_0.Data[6] := UINT_TO_BYTE(CRC_0.uiCRC);
            Send_0.Data[7] := UINT_TO_BYTE(SHR(CRC_0.uiCRC,8));
    END_CASE
END_ACTION

西门子1500PLC机器人焊接程序：智能化与高效能的西门子PLC+西门子触摸屏实现的综合控制系统
HpBCqpz的博客
04-22 1023
西门子1500PLC机器人焊接程序是一种集成了西门子PLC和西门子触摸屏的自动化控制系统，它通过多种通讯方式和智能模块的应用，实现对机器人焊接过程的精确控制和监测。多种通讯方式：除与智能模块和机器人的Profinet通讯外，该程序还支持与变频器、电能管理仪表、MES系统的通讯，实现焊接过程中各种设备的数据交互和协同控制。图尔克RFID总线模组通讯：RFID总线模组用于对焊接过程中的材料和工件进行识别和追踪，通过与PLC的通讯接口实现对焊接程序的数据交互。
西门子1500PLC机器人焊接程序(西门子PLC+西门子触摸屏)
m0_74276542的博客
10-14 1526
西门子1500PLC机器人焊接程序(西门子PLC+西门子触摸屏)9个智能远程终端ET200SP Profinet连接。10台Fanuc发那科机器人Profinet通讯。15个Festo智能模块Profinet通讯。程序经典，结构清晰，SCL算法，堆栈，梯形图。3台G120变频器Profinet通讯。2台智能电能管理仪表PAC3200。2台西门子触摸屏TP1500程序。和MES系统通讯，西门子安全模块。1台西门子1500PLC程序。图尔克RFID总线模组通讯。4个GRAPH顺控程序。程序:梯形图+SCL。
焊接机器人PLC程序
04-03
目录 1 常规技术安全提示 2 操作员职责 2 1.1.1 操作人员特别需要注意以下几点： 2 1.1.2 标准操作中的基本安全措施 2 1.1.3 维修与保养中的基本安全措施 2 1.1.4 在这本操作说明小册子中，仔细阅读每个零件的用法说明！ 2 电动设备的保养 3 改换中的禁令 3 个人保护设备 3 意外事故中的营救行为/急救 3 2 系统配置 4 机器人工作站系统配置 4 3 系统安全 4 工作站安全信号组成 4 4 工作站操作说明 4 4.1工作站工作准备 4 4.1.1 主控柜总开关闭合 4 4.1.2 机器人控制柜电源闭合 4 4.2 系统手动工作 4 4.2.1系统手动的条件： 4 4.4触摸屏画面介绍 5 4.4.1初始画面 5 4.4.2主画面 5 4.4.3动作设置画面 7 4.4.4手动画面 9 4.4.5报警画面 9 4.4.6用户画面 10 5 故障处理 10 5.1.1 当机器人出现报警时，可通过复位按钮进行复位。 10 5.1.2 无故障情况下，自动状态启动不了 10 5.1.3 机器人故障 10 5.1.4 紧急停止 10
贝加莱plc 温控程序模块
12-08
贝加莱plc 温控标准程序,调用标准库编程, 自整定程序 .
基于PLC系统的点焊机器人数据通讯采集方案
工业网络通讯解决方案
06-06 2172
点焊机器人多以PLC为控制系统，以安川（MOTOMAN）ES165D为例。安川ES165D电控系统，主要采用三菱FX1N、FX2N和FX3U系列PLC配合三菱GOT1000系列触摸屏实现。现在要在不影响原生产设备的基础上，实现全厂机器人的实时监控信息化系统。本方案主要解决机器人控制系统的通讯升级。 项目要求 根据生产设备信息化要求，将分布的点焊机器人的重要生产数据上传到数据中心；数据中心对数据进行分析处理。数据监控采集采用labview软件、数据通讯采用NI OPC、数据存储和分析采用SQLServer
152.锂电池自动碰焊设备.rar
04-25
《锂电池自动碰焊设备详解》 在现代科技的快速发展中，锂电池因其高能量密度、长寿命和环保特性，被广泛应用于各个领域，如电动汽车、移动设备等。在锂电池的生产过程中，碰焊作为一种重要的连接工艺，对电池的安全...
F17锂电池自动碰焊设备SW2012.rar
04-30
标题"F17锂电池自动碰焊设备SW2012.rar"揭示了这是一份与锂电池自动化生产设备相关的资料，特别是涉及到碰焊工艺。碰焊是一种在电池制造过程中常用的连接技术，用于将电芯的正负极片与其他部件如引脚、汇流条等焊接...
西门子PLC工程实例源码第569期：老外写的焊接机器人程序.rar
05-15
【工控老马出品，必属精品，亲测校正，质量保证】 资源名：西门子PLC工程实例源码第569期：老外写的焊接机器人程序.rar 资源类型：西门子PLC工程实例源码 源码说明： 全部项目源码都是经过测试校正后百分百成功运行的，如果您下载后不能运行可联系我进行指导或者更换。 适合人群：新手及有一定经验的开发人员
贝加莱PLC空调控制C源码
11-07
此程序为本公司项目开发使用的源代码，已经经过测试稳定后的版本，主要是用作自动化控制领域
三菱plc四轴机器人程序及详解
03-10
三菱plc四轴机器人程序及详解
贝加莱AS入门教程
07-20
贝加莱PCC编程工具入门教程，简单实用中文版。
最完整的贝加莱PLC培训教程1.pdf
04-03
最完整的贝加莱PLC培训教程,有需要的可以看看
机械手系统的PLC梯形图程序
05-14
在机械手搬运控制系统中的应用摘要：机械手是在机械化、自动化生产过程中发展起来的一种新型装置。它可在空间抓、放、搬运物体等，动作灵活多样，广泛应用在工业生产和其他领域内。应用PLC控制机械手能实现各种规定的工序动作，不仅可以提高产品的质量与产量，而且对保障人身安全，改善劳动环境，减轻劳动强度，提高劳动生产率，节约原材料消耗以及降低生产成本，有着十分重要的意义。本文以日本三菱FX2N-48MR型的PLC为基础，介绍PLC在机械手搬运控制中的应用，并给出了详细的PLC程序设计过程。该程序已在工业机械手中获得了广泛应用，具有稳定、可靠的性能。关键词：PLC·机械手，控制。应用1机械结构和控制要求如图1所示是一个将工件由A处传送到B处的机械手示意图，机械手的上升，下降和左移，右移的执行用双线圈二位电磁阀推动气缸完成。其中上升与下降对应电磁阀的线圈分别为YVl与w2，左行、右行对应电磁阀的线圈分别为YV3与YV4。当某个电磁阀线圈通电，就一直保持现有的机械动作，直到相对的另一线圈通电为止。气动机械手的夹紧，松开的动作由只有一个线圈的两位电磁阀驱动的气缸完成，线圈(YVS)断电夹住工件，线圈(YV5)通电，松开工件，以防止停电时的工件跌落。机械手的工作臂都设有上、下限位和左、右限位的位置开关SQl、SQ2和sQ3、SQ4，夹持装置不带限位开关，它是通过一定的延时来表示其夹持动作的完成。机械手在最上面、最左边且除松开的电磁线圈(YV5)通电外其它线圈全部断电的状态为机械手的原位。机械手的操作面板分布情况如图2所示，机械手具有手动、单步，单周期、连续和回原位五种工作方式，用开关SA进行选择。手动工作方式时，用各操作按钮(SB5、SB6，SB7、SB8、SB9、SBIO、SBll)来点动执行相应的各动作l单步工作方式时，每按一次起动按钮(SB3)，向前执行一步动作，单周期工作方式时，机械手在原位，按下起动按钮SB3，自动地执行一个工作周期的动作，最后返回原位(如果在动作过程中按下停止按钮SB4，机械手停在该工序上，再按下起动按钮SB3，则又从该工序继续工作，最后停在原位)j连续工作方式时，机械手在原位，按下起动按钮(SB3)，机械手就连续重复进行工作(如果按下停止按钮SB4，机械手运行到原位后停止)；返回原位工作方式时，按下。回原位”按钮SBll，机械手自动回到原位状态。2 LC的I／o分配如图3所示为PLC的I／O接线图，选用FX2N·48MR的PLC，系统共有18个输入设备和5个输出设备分别占用PLC的18个输入点和5个输出点。为了保证在紧急情况下(包括PLC发生故障时)，能可靠地切断PLC的负载电源，设置了交流接触器KM。在PLC开始运行时按下“电源”按钮SBl，使KM线圈得电并自锁，KM的主触点接通，给输出设备提供电源；出现紧急情况时，按下“急停”按钮SB2，KM触点断开电源。 PLC程序设计3．1程序的总体结构如图4所示为机械手系统的PLC梯形图程序的总体结构，将程序分为公用程序、自动程序、手动程序和回原位程序四个部分，其中自动程序包括单步、单周期和连续工作的程序，这是因为它们的工作都是按照同样的顺序进行，所以将它们合在一起编程更加简单。梯形图中使用跳转指令使得自动程序、手动程序和回原位程序不会同时执行。假设选择。手动”方式，则X0为ON、X1为OFF，此时PLC执行完公用程序后，将跳过动程序到P0处，由于X0常闭触点为断开，故执行“手动程序”，执行到P1处，由于X1常闭触点为闭合，所以又跳过回原位程序到P2处l假设选择分“回原位”方式，则X0为OFF、X1为ON，跳过自动程序和手动程序执行回原位程序，假设选择“单步”或“单周期”或“连续”方式，则X0、X1均为OFF，此时执行完自动程序后，跳过手动程序和回原位程序。3．2各部分程序的设计(1)公用程序公用程序如图5所示，左限位开关X12、上限位开关X10的常开触点和表示机械手松开的Y4的常开触点的串联电路接通时，辅助继电器M0变为ON，表示机械手在原位。公用程序用于自动程序和手动程序相互切换的处理，当系统处于手动工作方式时，必须将除初始步以外的各步对应的辅助继电器(M1I-M18)复位，同时将表示连续工作状态的M1复位，否则当系统从自动工作方式切换到手动工作方式，然后又返回自动
基于PLC的三轴直角机器人控制系统设计【附代码】
最新发布
lagougongzuoshi的博客
10-28 1323
在重复定位精度测试中，通过多次重复相同路径的运动，检测机器人最终的位置误差，测试结果表明，机器人能够达到毫米级的重复定位精度，完全符合中小企业对自动化生产的需求。在设计总体方案时，本文首先分析了三轴直角机器人的运动特性和使用环境，确定了机器人控制系统的硬件结构，包括PLC、伺服电机、传感器、触摸屏和机械结构等。PLC控制系统通过对伺服电机的转矩和速度进行控制，从而实现对机器人的精确定位。通过触摸屏，操作员可以对机器人进行手动和自动模式的切换，设定各轴的运动参数，以及查看机器人运行过程中的状态信息。
【贝加莱PLC基础教学】2.5.AutiomationStudio基础编程与仿真
A1617215315的博客
10-14 3738
新手入门AS组态、编程和仿真。
B&R 4P3040.00-490 标准PLC采用梯形逻辑编程
zhang13365909307的博客
06-01 520
电源面板PP41 5.7英寸QVGA黑/白LC显示屏，8个软键和32个功能键，系统兼容2003 CPU，700 kB SRAM，1.4 MB FlashPROM，1个PCMCIA插槽，1个RS232接口，1个CAN接口：电隔离，可联网，6个插槽用于旋入模块，10个数字输入24 VDC，8个数字输出24 VDC，0.4 A，防护IP65（从前），205 x 220 mm（宽x高），24 VDC。B&R 4P3040.00-490 奥地利贝加莱 电源面板。
ABB机器人和西门子PLC组成的立库码垛系统，SCL和梯形图混编，经典程序，涉及多个知识点
HolaTuYQM的博客
04-11 978
摘要：本文围绕ABB机器人和西门子PLC在工业自动化领域的应用展开，重点介绍了视觉定位、通信和控制等方面的关键技术和知识点。本文将通过2台西门子PLC1215程序和2台西门子触摸屏TP700程序，结合伺服轴、基恩士相机视觉定位、ABB机器人和码垛机的通信等实际案例，展示ABB机器人和西门子PLC在工业自动化中的实际应用效果。本文将详细介绍了ABB机器人和西门子PLC之间的通信技术，包括MODBUS和TCP通信协议的应用、SCL编程实现等。标题：工业自动化中的ABB机器人和西门子PLC应用。
PLC机器人控制器编程笔记
MrBlake的博客
09-25 1853
文章整理了相关基础知识，并以实际应用的消防排烟机器人的控制程序为例，描述了变量捕捉、线性变换等常用的功能，详细阐述了机器人液压控制模块、云台控制模块、报警功能模块等部分的编程逻辑
锂电池自动碰焊设备技术解析与应用
资源摘要信息:"锂电池自动碰焊设备" 知识点: 一、锂电池技术概述 锂电池是一种化学电源，它以锂离子在正负极之间的移动来实现充放电。锂电池具有能量密度高、自放电小、无记忆效应、循环寿命长等特点，是目前广泛...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

!chen

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值