//Copyright (C) jiansiting 2007. All Rights Reserved. Confidential
 //**************************************************************************************
 // Block header
 //**************************************************************************************
 
FUNCTION_BLOCK LED_H
 TITLE =   'LED_H'
 {                            // List of system attributes
 //S7_tasklist:= 'OB80,OB100';  // Block is called if there is a time error and at a warm restart
 S7_m_c:=      'true';        // Block can be controlled and monitored
 S7_alarm_ui:= '1'            // Setting for PCS 7 message dialog ('0'=standard message dialog)
 }
 AUTHOR:   LOGGY
 NAME:        LED_H
 VERSION:      '0.01'
 FAMILY:   CS2PA
 KNOW_HOW_PROTECT
 
//**************************************************************************************
 // Declaration Section: Block Parameters
 //**************************************************************************************
 
//System attributes for parameters
 (*
 S7_sampletime:='true'
 S7_dynamic:='true'
 S7_edit:='true'
 S7_link:='true'
 S7_param:='true'
 S7_visible:='true'
 S7_contact:='true'
 S7_m_c:='true'
 S7_shortcut:=''
 S7_string_0:=''
 S7_string_1:=''
 S7_unit:=''
 S7_server:='alarm_archiv'
 S7_a_type:='alarm_8p'
 *)
 
VAR_INPUT
 
  EV_ID   {
            S7_visible:='false';
            S7_link:='false';
            S7_param :='false';                // Parameter cannot be set in CFC
            S7_server:='alarm_archiv';         // Message no. assigned by server
           S7_a_type:='alarm_8p'              // Block signals with ALARM_8P
           }:DWORD := 0;           // Message ID
 
  RUNUPCYC{
            S7_visible:='false';
            S7_link:='false'
            } :INT := 3;           // Number of run up cycles
           
  REQ {S7_string_0:='No_req'; S7_string_1:='Req'}: BOOL;
  
  SSL_ID : WORD := W#16#0074; 
 
  INDEX : WORD := W#16#0;
  
 
END_VAR
 
VAR_OUTPUT
 
  LENTHDR : WORD;
   N_DR{
        S7_m_c:='true'} : WORD;
     
  LED_ID1{
          // S7_m_c:='true';
           S7_visible :='false'} : WORD;
   LED_ID2{
          // S7_m_c:='true';
           S7_visible :='false'} : WORD; 
  LED_ID3{
          // S7_m_c:='true';
           S7_visible :='false'} : WORD;  
  LED_ID4{
         //  S7_m_c:='true';
           S7_visible :='false'} : WORD;
   LED_ID5{
         //  S7_m_c:='true';
           S7_visible :='false'} : WORD;
   LED_ID6{
         //  S7_m_c:='true';
           S7_visible :='false'} : WORD;
   LED_ID7{
         //  S7_m_c:='true';
           S7_visible :='false'} : WORD;
   LED_ID8{
         //  S7_m_c:='true';
           S7_visible :='false'} : WORD;
   LED_ID9{
        //   S7_m_c:='true';
           S7_visible :='false'} : WORD;
   LED_ID10{
        //   S7_m_c:='true';
           S7_visible :='false'} : WORD;
   LED_ID11{
        //   S7_m_c:='true';
           S7_visible :='false'} : WORD;
   LED_ID12{
        //   S7_m_c:='true';
           S7_visible :='false'} : WORD;
   LED_ID13{
        //   S7_m_c:='true';
           S7_visible :='false'} : WORD;
   LED_ID14{
        //   S7_m_c:='true';
           S7_visible :='false'} : WORD;
   LED_ID15{
         //  S7_m_c:='true';
           S7_visible :='false'} : WORD;
   LED_ID16{
        //   S7_m_c:='true';
           S7_visible :='false'} : WORD;
   LED_ID17{
        //   S7_m_c:='true';
           S7_visible :='false'} : WORD;
   LED_ID18{
       //    S7_m_c:='true';
           S7_visible :='false'} : WORD;
   LED_ID19{
        //   S7_m_c:='true';
           S7_visible :='false'} : WORD;
   LED_ID20{
        //   S7_m_c:='true';
           S7_visible :='false'} : WORD; 
  LED_ID21{
       //    S7_m_c:='true';
           S7_visible :='false'} : WORD;
   LED_ID22{
        //   S7_m_c:='true';
           S7_visible :='false'} : WORD;
   LED_ID23{
           S7_m_c:='true';
           S7_visible :='false'} : WORD;
   LED_ID24{
        //   S7_m_c:='true';
           S7_visible :='false'} : WORD;
   LED_ID25{
        //   S7_m_c:='true';
           S7_visible :='false'} : WORD; 
  LED_ID26{
        //   S7_m_c:='true';
           S7_visible :='false'} : WORD;       
                         
  LED_ON
       {
         S7_m_c:='true'
        } : DWORD;
   LED_BLINK
       {
         S7_m_c:='true'
        } : DWORD;
       
  BUSY {S7_visible :='false'}: BOOL;
  
  CPU_FAILURE
         {
          S7_m_c:='true'
         } : BOOL;
        
  CPU_FAULT
         {
          S7_m_c:='true'
         } : BOOL;
    
  QMSG_ERR  {
             S7_visible:='false';
             S7_dynamic:='true'} :  BOOL := 0;        // ALARM_8P: Error output
 
  MSG_STAT  {
             S7_visible:='false';
             S7_dynamic:='true'} :  WORD := 0;        // Message: STATUS output
 
  MSG_ACK   {
             S7_visible:='false';
             S7_dynamic:='true'} :  WORD := 0;        // Message: ACK_STATE output
 
END_VAR
 
VAR_IN_OUT
 
 // Freely assignable auxiliary values of ALARM_8P
   AUX_PR01 {S7_visible := 'false'} : ANY;  // Auxiliary value 1 
  AUX_PR02 {S7_visible := 'false'} : ANY;  // Auxiliary value 2
   AUX_PR03 {S7_visible := 'false'} : ANY;  // Auxiliary value 3
   AUX_PR04 {S7_visible := 'false'} : ANY;  // Auxiliary value 4
   AUX_PR05 {S7_visible := 'false'} : ANY;  // Auxiliary value 5
   AUX_PR06 {S7_visible := 'false'} : ANY;  // Auxiliary value 6
   AUX_PR07 {S7_visible := 'false'} : ANY;  // Auxiliary value 7
   AUX_PR08 {S7_visible := 'false'} : ANY;  // Auxiliary value 8
   AUX_PR09 {S7_visible := 'false'} : ANY;  // Auxiliary value 9
   AUX_PR10 {S7_visible := 'false'} : ANY;  // Auxiliary value 10
 
END_VAR
 
//**************************************************************************************
 // Declaration Section: Static Variables
 //**************************************************************************************
 VAR
  
  DR : ARRAY[1..26] OF STRUCT
       CPU_LED_ID : WORD;
       LED_ON : BYTE;
       LED_BLINK : BYTE;
   END_STRUCT;
  
  SZL_HEADER : STRUCT
       LENTHDR : WORD;
       N_DR : WORD;
   END_STRUCT;
    
  sbRESTART   :BOOL := TRUE;       // Initial start memory bit
   siRUNUPCNT  :INT := 0;           // Counter for RUNUPCYC execution
 
//**************************************************************************************
 // Declaration Section Multiple Instances(SFB/FB), remember to copy the FB/FC blocks into your projects manually!
 //**************************************************************************************
  
  ALARM_8P_1:  ALARM_8P;   // Generation of max. 8 messages with max. 10 auxiliary values
 END_VAR
 
//**************************************************************************************
 // Declaration Section: Temporary Variables
 //**************************************************************************************
 
VAR_TEMP
   // Start info: Structure with info for the OB that has just called the block
   TOP_SI:    STRUCT     
   EV_CLASS :BYTE;
    EV_NUM   :BYTE;
    PRIORITY :BYTE;
    NUM      :BYTE;
    TYP2_3   :BYTE;
    TYP1     :BYTE;
    ZI1      :WORD;
    ZI2_3    :DWORD;
   END_STRUCT;
 
  // Start info: Structure with info for the last called startup OB
  START_UP_SI:  STRUCT
    EV_CLASS :BYTE;
    EV_NUM   :BYTE;
    PRIORITY :BYTE;
    NUM      :BYTE;
    TYP2_3   :BYTE;
    TYP1     :BYTE;
    ZI1      :WORD;
    ZI2_3    :DWORD;
   END_STRUCT;
 
  DUMMY  :INT;                     // Auxiliary variable
  
  ALARM_OUT :BOOL;
   TEMP1 : INT;
   TEMP2,TEMP3,TEMP4,TEMP5 : DWORD;
   TEMP6 : WORD;
 
 END_VAR
 
//**************************************************************************************
 // Code Section
 //*************************************************************************************
 
//*************************************************************************************
 // Dependence on Calling OB
 //*************************************************************************************
 
// Read out start info with SFC6 (RD_SINFO)
   DUMMY := RD_SINFO (TOP_SI := TOP_SI, START_UP_SI := START_UP_SI);
  
 IF sbRESTART THEN
   // Initial start 
  TOP_SI.NUM := 100;         // Execute initial start as warm restart
   sbRESTART := FALSE;         // Reset initial start
  END_IF;
 
// In which OB was the block called ?
 
 CASE WORD_TO_INT(BYTE_TO_WORD(TOP_SI.NUM)) OF
 
//************************************************************************************
 // Handling Error OBs
 //************************************************************************************
 // OB80: time error
     80:
     ;
 //************************************************************************************
 // Startup
 //************************************************************************************
 // OB100: Warm restart
     100:
     ;
     siRUNUPCNT := RUNUPCYC;  // Save RUNUPCYC value
  ELSE
 //**********************************************************************************
 // Technological Section
 //**********************************************************************************
  //get the LED status from controller
     TEMP1:=RDSYSST(REQ :=REQ  // IN: BOOL
             ,SZL_ID :=SSL_ID  // IN: WORD
             ,INDEX :=INDEX  // IN: WORD
             ,BUSY :=BUSY  // OUT: BOOL
             ,SZL_HEADER :=SZL_HEADER  // OUT: STRUCT
             ,DR :=DR  // OUT: ANY
             ); // INT
     LENTHDR := SZL_HEADER.LENTHDR;
     N_DR := SZL_HEADER.N_DR;
     IF N_DR=W#16#D THEN
         CPU_FAILURE :=TRUE;
     ELSE
         CPU_FAILURE :=FALSE;
     END_IF;
 
 //filter the data and construct the data for displaying in OS
    TEMP3 :=BYTE_TO_DWORD(DR[1].LED_ON);
     TEMP4 :=BYTE_TO_DWORD(DR[1].LED_BLINK)AND DW#16#1;
    FOR TEMP1:= 1 TO (WORD_TO_INT(SZL_HEADER.N_DR)-1) BY 1 DO
     // Statement Section
      TEMP2 :=ROL(IN:=BYTE_TO_DWORD(DR[TEMP1+1].LED_ON), N :=TEMP1);
      TEMP3 :=TEMP3 OR TEMP2;
      TEMP5 :=ROL(IN:=BYTE_TO_DWORD(DR[TEMP1+1].LED_BLINK), N :=TEMP1) AND ROL(IN:=DW#16#1, N :=TEMP1);
      TEMP4 :=TEMP4 OR TEMP5;
     END_FOR;
     TEMP6 :=DR[1].CPU_LED_ID AND W#16#FF00;
     IF TEMP6=W#16#F900 THEN
         TEMP2 :=ROR(IN:=TEMP3 AND DW#16#03FFD000, N :=13);
         TEMP5 :=ROL(IN:=TEMP3 AND DW#16#00001FFF, N :=13);
         TEMP3 :=TEMP2 OR TEMP5;
         TEMP2 :=ROR(IN:=TEMP4 AND DW#16#03FFD000, N :=13);
         TEMP5 :=ROL(IN:=TEMP4 AND DW#16#00001FFF, N :=13);
         TEMP4 :=TEMP2 OR TEMP5;   
    ELSE
         ;
     END_IF;
     TEMP2 :=TEMP3 AND DW#16#001C60E3;
     IF TEMP2 <> DW#16#0 THEN
         CPU_FAULT :=TRUE;
     ELSE
         CPU_FAULT :=FALSE;
     END_IF;
       
 
    LED_ID1 := DR[1].CPU_LED_ID;
     LED_ID2 := DR[2].CPU_LED_ID;
     LED_ID3 := DR[3].CPU_LED_ID;
     LED_ID4 := DR[4].CPU_LED_ID; 
    LED_ID5 := DR[5].CPU_LED_ID;
     LED_ID6 := DR[6].CPU_LED_ID;
     LED_ID7 := DR[7].CPU_LED_ID;
     LED_ID8 := DR[8].CPU_LED_ID;
     LED_ID9 := DR[9].CPU_LED_ID;
     LED_ID10 := DR[10].CPU_LED_ID;
     LED_ID11 := DR[11].CPU_LED_ID;
     LED_ID12 := DR[12].CPU_LED_ID;
     LED_ID13 := DR[13].CPU_LED_ID;
     LED_ID14 := DR[14].CPU_LED_ID;
     LED_ID15 := DR[15].CPU_LED_ID;
     LED_ID16 := DR[16].CPU_LED_ID;
     LED_ID17 := DR[17].CPU_LED_ID;
     LED_ID18 := DR[18].CPU_LED_ID;
     LED_ID19 := DR[19].CPU_LED_ID;
     LED_ID20 := DR[20].CPU_LED_ID;
     LED_ID21 := DR[21].CPU_LED_ID;
     LED_ID22 := DR[22].CPU_LED_ID;
     LED_ID23 := DR[23].CPU_LED_ID;
     LED_ID24 := DR[24].CPU_LED_ID;
     LED_ID25 := DR[25].CPU_LED_ID;                                                                                     
    LED_ID26 := DR[26].CPU_LED_ID;
      
    LED_ON :=TEMP3;
     LED_BLINK :=TEMP4;
     ;
 //**********************************************************************************
 // Message suppression during the startup   
//**********************************************************************************
 
  IF siRUNUPCNT = 0               // RUNUPCYC cycle already elapsed ?
   THEN
    ALARM_OUT :=TRUE;
   ELSE
    siRUNUPCNT := siRUNUPCNT - 1;
   END_IF;
 END_CASE;
 
//**************************************************************************************
 // Messages with ALARM_8P
 //**************************************************************************************
  
// STRING variables must not be linked to ALARM8_P as auxiliary values
 // so transfer in array of bytes
 
 ALARM_8P_1
      (EN_R := TRUE,    // Update output ACK_STATE
       ID := 16#EEEE,         // Data channel for messages (always 16#EEEE)
       EV_ID:= EV_ID,         // Message number > 0
       SIG_1:= ALARM_OUT AND CPU_FAILURE,                        // Signal 1 to be monitored
      SIG_2:= ALARM_OUT AND CPU_FAULT,                        // Signal 2 to be monitored
      SIG_3:= 0,                        // Signal 3 to be monitored 
      SIG_4:= 0,                        // Signal 4 to be monitored
      SIG_5:= 0,                        // Signal 5 to be monitored
       SIG_6:= 0,                        // Signal 6 to be monitored
       SIG_7:= 0,                        // Signal 7 to be monitored
       SIG_8:= 0,                        // Signal 8 to be monitored
       SD_1 := AUX_PR01,      // Auxiliary value 1
       SD_2 := AUX_PR02,     // Auxiliary value 2
       SD_3 := AUX_PR03,       // Auxiliary value 3
       SD_4 := AUX_PR04,       // Auxiliary value 4
       SD_5 := AUX_PR05,      // Auxiliary value 5
       SD_6 := AUX_PR06,      // Auxiliary value 6
       SD_7 := AUX_PR07,      // Auxiliary value 7
       SD_8 := AUX_PR08,      // Auxiliary value 8
       SD_9 := AUX_PR09,      // Auxiliary value 9
       SD_10:= AUX_PR10);     // Auxiliary value 10
    
    QMSG_ERR := ALARM_8P_1.ERROR;      // ERROR status parameter
     MSG_STAT := ALARM_8P_1.STATUS;     // STATUS status parameter
     MSG_ACK := ALARM_8P_1.ACK_STATE;   // Current OS confirmation status
   
END_FUNCTION_BLOCK