开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 能源行业(电力石油煤炭) > 查看源码
dp_msac1.c
资源名称：Profibus.rar　[点击查看]
上传用户：hualang
上传日期：2022-04-11
资源大小：104k
文件大小：61k
源码类别：

能源行业(电力石油煤炭)

开发平台：

C/C++

dp_msac1.c：源码内容
  1. /**********************  Filename: dp_msac1.c  *******************************/
  2. /* ========================================================================= */
  3. /*                                                                           */
  4. /* 0000  000   000  00000 0  000  0   0 0 0000                               */
  5. /* 0   0 0  0 0   0 0     0 0   0 0   0 0 0   0                              */
  6. /* 0   0 0  0 0   0 0     0 0     0   0 0 0   0      Einsteinstra遝 6        */
  7. /* 0000  000  0   0 000   0 0     00000 0 0000       91074 Herzogenaurach    */
  8. /* 0     00   0   0 0     0 0     0   0 0 0                                  */
  9. /* 0     0 0  0   0 0     0 0   0 0   0 0 0          Tel: ++49-9132-744-200  */
  10. /* 0     0  0  000  0     0  000  0   0 0 0    GmbH  Fax: ++49-9132-744-204  */
  11. /*                                                                           */
  12. /* ========================================================================= */
  13. /*                                                                           */
  14. /* Function:       MSAC_C1 functions                                         */
  15. /*                                                                           */
  16. /* ------------------------------------------------------------------------- */
  17. /*                                                                           */
  18. /* Technical support:       P. Fredehorst                                    */
  19. /*                          Tel. : ++49-9132/744-214                         */
  20. /*                          Fax. :              -204                         */
  21. /*                          eMail: pfredehorst@profichip.com                 */
  22. /*                                                                           */
  23. /*****************************************************************************/
  26. /*****************************************************************************/
  27. /* contents:
  29.   - function prototypes
  30.   - data structures
  31.   - internal functions
  33. */
  34. /*****************************************************************************/
  35. /* include hierarchy */
  36. #include "..dp_incplatform.h"
  37. #include "..dp_incdp_inc.h"
  38. //#include "E5_Inc.h"
  41. #ifdef DP_MSAC_C1
  44. /*---------------------------------------------------------------------------*/
  45. /* function prototypes                                                       */
  46. /*---------------------------------------------------------------------------*/
  47. MSAC1_OPMODE        msac_c1_get_new_operation_mode  (UBYTE dev_num);
  48. void                msac_c1_set_job_running         (UBYTE dev_num, UBYTE running );
  49. void                msac_c1_ind_disable_done        (UBYTE dev_num, UBYTE sap_nr, UBYTE ret_val );
  50. void                msac_c1_stop                    (UBYTE dev_num);
  52. #ifdef DP_ALARM
  53.     void            stop_asm                        (UBYTE dev_num);
  54.     void            set_new_alarm_mode              (UBYTE dev_num);
  55.     UBYTE           alarm_enabled                   (UBYTE dev_num, UBYTE alarm_type );
  56.     UBYTE           acls                            (UBYTE dev_num, UBYTE alarm_type );
  57.     void            init_alarm                      (UBYTE dev_num, UBYTE power_on );
  58.     UBYTE           check_sequence_status           (UBYTE dev_num, UBYTE action, UBYTE alarm_type, UBYTE alarm_specifier );
  59.     UBYTE           check_type_status               (UBYTE dev_num, UBYTE action, UBYTE alarm_type );
  60.     UBYTE           check_send_diag                 (UBYTE dev_num, UBYTE alarm_type, ALARM_STATUS_PDU_PTR alarm_ptr, UBYTE callback );
  61.     void            check_send_alarm                (UBYTE dev_num);
  62.     DPV1_RET_VAL    msac_c1_alarm_quit              (UBYTE dev_num, UBYTE sap, DPV1_PTR pdu );
  63. #endif // #ifdef DP_ALARM
  66. /*---------------------------------------------------------------------------*/
  67. /* global variables                                                          */
  68. /*---------------------------------------------------------------------------*/
  69. #ifdef DP_FDL
  70. SECTION_DEF_CommuData  static    IND_RESP_BUF_PTR    dpv1_act_ind_ptr[MAX_DEV_NUM];
  71. SECTION_DEF_CommuData  static    IND_RESP_BUF_PTR    dpv1_act_ind_SAP50_ptr[MAX_DEV_NUM];
  72. #endif
  74. #ifdef DP_ALARM
  75.     // table for decoding the number of parallel alarms
  76. SECTION_DEF_CommuData  static    UBYTE alarm_decode[MAX_DEV_NUM][ALARM_TYPE_MAX+1];   //wusenlin 原先为ALARM_TYPE_MAX，+1防止越界
  77.     // this variable is used to store the status pdu
  78. //SECTION_DEF_CommuData  static    ALARM_STATUS_PDU  status_buffer[MAX_DEV_NUM];
  79. #endif // #ifdef DP_ALARM
  82. /*--------------------------------------------------------------------------*/
  83. /* function: msac_c1_init                                                   */
  84. /*--------------------------------------------------------------------------*/
  85. SECTION_DEF_CommuCode DP_ERROR_CODE msac_c1_init(UBYTE dev_num)
  86. {
  87. DP_ERROR_CODE error;
  89.     error = DP_OK;
  91.     dp_sys[dev_num].c1.DX_Entered     = FALSE;
  92.     dp_sys[dev_num].c1.Operation_Mode = DP_OPMODE_V0;
  93.     dp_sys[dev_num].c1.Start_State    = DP_SS_IDLE;
  94.     dp_sys[dev_num].c1.Fdl_Closing    = TRUE;
  95.     dp_sys[dev_num].c1.active_Job     = FALSE;
  96.     dp_sys[dev_num].c1.event          = 0x00;
  98. #ifdef DP_ALARM
  99.     init_alarm(dev_num, TRUE );
  100. #endif // #ifdef DP_ALARM
  101.     return error;
  102. }//DP_ERROR_CODE msac_c1_init(UBYTE dev_num)
  104. /*--------------------------------------------------------------------------*/
  105. /* function: msac_c1_pdu_received                                           */
  106. /*--------------------------------------------------------------------------*/
  107. SECTION_DEF_CommuCode void msac_c1_pdu_received(UBYTE dev_num, UBYTE sap_nr, IND_RESP_BUF_PTR ind_ptr, UBYTE req_add )
  108. {
  109. DPV1_PTR dpx_pdu_ptr = ((DPV1_PTR) &ind_ptr->user_data[0]);
  111.     DP_LOCK_IND(dev_num);
  113.     req_add = req_add;
  115.     switch( sap_nr )
  116.     {
  117.         case DP_C1_RD_WR_SAP_NR:
  118.         {
  119.             dpv1_act_ind_ptr[dev_num] = ind_ptr;
  121.             switch( BFWORD2BYTE(dpx_pdu_ptr->read.function_num) )
  122.             {
  123.                 case DPV1_FC_READ:
  124.                 {
  125.                     if( (BFWORD2BYTE(dpx_pdu_ptr->read.length) > 0) && (BFWORD2BYTE(dpx_pdu_ptr->read.length) <=240) && (BFWORD2BYTE(ind_ptr->data_len) == 4) )
  126.                     {
  127.                         dp_sys[dev_num].c1.event |= MSAC_C1_IND_DS_READ;
  128.                     }//if( (dpx_pdu_ptr->read.length > 0) && (dpx_pdu_ptr->read.length <=240) )
  129.                     else
  130.                     {
  131.                         dpx_pdu_ptr->read.function_num |= DPV1_ERROR_BIT_RESPONSE;
  132.                         ind_ptr->data_len = DPV1_LEN_NEG_RESPONSE;
  133.                         ind_ptr->fc       = FC_RESP_L;
  135.                         dpx_pdu_ptr->neg.err_decode = DPV1_ERRDC_DPV1;
  136.                         dpx_pdu_ptr->neg.err_code1 = DPV1_ERRCL_ACCESS | DPV1_ERRCL_ACC_TYPE;
  137.                         dpx_pdu_ptr->neg.err_code2 = 0x00;
  139.                         fdl_resp_provide(dev_num, sap_nr, FDL_PRIMARY_BUF );
  140.                     }//else of if( (dpx_pdu_ptr->read.length > 0) && (dpx_pdu_ptr->read.length <=240) )
  141.                     break;
  142.                 }//case DPV1_FC_READ:
  144.                 case DPV1_FC_WRITE:
  145.                 {
  146.                     if( BFWORD2BYTE(dpx_pdu_ptr->write.length) > 0 )
  147.                     {
  148.                         dp_sys[dev_num].c1.event |= MSAC_C1_IND_DS_WRITE;
  149.                     }//if( dpx_pdu_ptr->write.length > 0 )
  150.                     else
  151.                     {
  152.                         dpx_pdu_ptr->write.function_num |= DPV1_ERROR_BIT_RESPONSE;
  153.                         ind_ptr->data_len = DPV1_LEN_NEG_RESPONSE;
  154.                         ind_ptr->fc       = FC_RESP_L;
  156.                         dpx_pdu_ptr->neg.err_decode = DPV1_ERRDC_DPV1;
  157.                         dpx_pdu_ptr->neg.err_code1 = DPV1_ERRCL_ACCESS | DPV1_ERRCL_ACC_TYPE;
  158.                         dpx_pdu_ptr->neg.err_code2 = 0x00;
  160.                         fdl_resp_provide(dev_num, sap_nr, FDL_PRIMARY_BUF );
  161.                     }//else of if( dpx_pdu_ptr->write.length > 0 )
  162.                     break;
  163.                 }//case DPV1_FC_WRITE:
  165.                 #ifdef DP_ALARM
  166.                     case DPV1_FC_ALARM_ACK:  
  167.                     {
  168. logMsg2("DPV1-----step4!n",0,0,0,0,0,0);
  169.                         // check, if Alarm functions enabled
  170.                         if( dp_sys[dev_num].al.state == AL_STATE_OPEN )
  171.                         {
  172.                             dp_sys[dev_num].c1.event |= MSAC_C1_IND_ALARM_QUIT;
  173.                         }//if( dp_sys[dev_num].al.state == AL_STATE_OPEN )
  174.                         else
  175.                         {
  176. logMsg2("VPC3_SET_USER_LEAVE_MASTER--1!n",0,0,0,0,0,0);
  177.                             VPC3_SET_USER_LEAVE_MASTER(dev_num);
  178.                         }//else of if( dp_sys[dev_num].al.state == AL_STATE_OPEN )
  179.                         break;
  180.                     }//case DPV1_FC_ALARM_ACK:
  181.                 #endif
  183.                 default:
  184.                 {
  185. logMsg2("VPC3_SET_USER_LEAVE_MASTER--2!n",0,0,0,0,0,0);
  186.                     VPC3_SET_USER_LEAVE_MASTER(dev_num);
  187.                     break;
  188.                 }//default:
  189.             }//switch( dpx_pdu_ptr->read.function_num )
  190.             break;
  191.         }//case DP_C1_RD_WR_SAP_NR
  193.         #ifdef DP_ALARM
  194.             case DP_C1_ALARM_SAP_NR:
  195.             {
  196.                 if( BFWORD2BYTE(dpx_pdu_ptr->read.function_num) == DPV1_FC_ALARM_ACK )
  197.                 {
  198.                     //check, if Alarm functions enabled
  199.                     if( dp_sys[dev_num].al.state == AL_STATE_OPEN )
  200.                     {
  201.                         dpv1_act_ind_SAP50_ptr[dev_num] = ind_ptr;
  202.                         dp_sys[dev_num].c1.event |= MSAC_C1_IND_ALARM_QUIT_SAP50;
  203.                     }//if( dp_sys[dev_num].al.state == AL_STATE_OPEN )
  204.                     else
  205.                     {
  206. logMsg2("VPC3_SET_USER_LEAVE_MASTER--3!n",0,0,0,0,0,0);
  207.                         VPC3_SET_USER_LEAVE_MASTER(dev_num);
  208.                     }//else of if( dp_sys[dev_num].al.state == AL_STATE_OPEN )
  209.                 }//if( dpx_pdu_ptr->read.function_num == DPV1_FC_ALARM_ACK )
  210.                 else
  211.                 {
  212. logMsg2("VPC3_SET_USER_LEAVE_MASTER--4!n",0,0,0,0,0,0);
  213.                     VPC3_SET_USER_LEAVE_MASTER(dev_num);
  214.                 }//else of if( dpx_pdu_ptr->read.function_num == DPV1_FC_ALARM_ACK )
  215.                 break;
  216.             }//case DP_C1_ALARM_SAP_NR:
  217.         #endif//#ifdef DP_ALARM
  219.         default:
  220.         {
  221. logMsg("VPC3_SET_USER_LEAVE_MASTER--5!n",0,0,0,0,0,0);
  222.             VPC3_SET_USER_LEAVE_MASTER(dev_num);
  223.             break;
  224.         }//default:
  225.     }//switch( sap_nr )
  227.     DP_UNLOCK_IND(dev_num);
  228. }//void msac_c1_pdu_received(UBYTE dev_num, UBYTE sap_nr, IND_RESP_BUF_PTR ind_ptr, UBYTE req_add )
  230. /*--------------------------------------------------------------------------*/
  231. /* function: msac_c1_process                                                */
  232. /*--------------------------------------------------------------------------*/
  233. SECTION_DEF_CommuCode void msac_c1_process(UBYTE dev_num)
  234. {
  235. DPV1_PTR    dpv1_act_pdu_ptr;
  237.     if( dp_sys[dev_num].c1.Operation_Mode == DP_OPMODE_V1 )
  238.     {
  239.         if( dp_sys[dev_num].c1.event & MSAC_C1_IND_DS_READ )
  240.         {
  241.             dpv1_act_pdu_ptr = ((DPV1_PTR) &dpv1_act_ind_ptr[dev_num]->user_data[0]);
  242.             msac_c1_set_job_running(dev_num,TRUE);
  244.             switch (user_dpv1_read_req(dev_num,DP_C1_RD_WR_SAP_NR, (DPV1_PTR) dpv1_act_pdu_ptr) )
  245.             {
  246.                 case DPV1_OK:
  247.                 {
  248.                     dpv1_act_ind_ptr[dev_num]->data_len = DPV1_LEN_HEAD_DATA + BFWORD2BYTE(dpv1_act_pdu_ptr->read.length);
  249.                     dpv1_act_ind_ptr[dev_num]->fc       = FC_RESP_L;
  250.                     fdl_resp_provide(dev_num, DP_C1_RD_WR_SAP_NR, FDL_PRIMARY_BUF );
  251.                     msac_c1_set_job_running(dev_num, FALSE );
  253.                     dp_sys[dev_num].c1.event &= ~MSAC_C1_IND_DS_READ;
  254.                     break;
  255.                 }//case DPV1_OK:
  257.                 case DPV1_NOK:
  258.                 {
  259.                     dpv1_act_pdu_ptr->read.function_num |= DPV1_ERROR_BIT_RESPONSE;
  260.                     dpv1_act_pdu_ptr->neg.err_decode = DPV1_ERRDC_DPV1;
  262.                     dpv1_act_ind_ptr[dev_num]->data_len = DPV1_LEN_NEG_RESPONSE;
  263.                     dpv1_act_ind_ptr[dev_num]->fc       = FC_RESP_L;
  264.                     fdl_resp_provide(dev_num, DP_C1_RD_WR_SAP_NR, FDL_PRIMARY_BUF );
  265.                     msac_c1_set_job_running(dev_num, FALSE );
  267.                     dp_sys[dev_num].c1.event &= ~MSAC_C1_IND_DS_READ;
  268.                     break;
  269.                 }//case DPV1_NOK:
  271.                 case DPV1_DELAY:
  272.                 {
  273.                     /* user give pdu later back */
  274.                     dp_sys[dev_num].c1.event &= ~MSAC_C1_IND_DS_READ;
  275.                     break;
  276.                 }//case DPV1_DELAY:
  278.                 default:
  279.                 {
  280.                     vpc3_errcb[dev_num].error_code = dp_sys[dev_num].c1.event;
  281.                     vpc3_errcb[dev_num].cn_id      = 0;
  282.                     // *** no further action of dpv1/c2 ***
  283.                     fatal_error(dev_num,_DP_C1, __LINE__, &vpc3_errcb[dev_num]);
  284.                     break;
  285.                 }//default:
  286.             }//switch (user_dpv1_read_req(dev_num,DP_C1_RD_WR_SAP_NR, (DPV1_PTR) dpv1_act_pdu_ptr) )
  287.         }//if( dp_sys[dev_num].c1.event & MSAC_C1_IND_DS_READ )
  289.         if( dp_sys[dev_num].c1.event & MSAC_C1_IND_DS_WRITE )
  290.         {
  291.             dpv1_act_pdu_ptr = ((DPV1_PTR) &dpv1_act_ind_ptr[dev_num]->user_data[0]);
  292.             msac_c1_set_job_running(dev_num, TRUE );
  294.             switch( user_dpv1_write_req(dev_num,DP_C1_RD_WR_SAP_NR,(DPV1_PTR) dpv1_act_pdu_ptr) )
  295.             {
  296.                 case DPV1_OK:
  297.                 {
  298.                     dpv1_act_ind_ptr[dev_num]->data_len = DPV1_LEN_HEAD_DATA;
  299.                     dpv1_act_ind_ptr[dev_num]->fc       = FC_RESP_L;
  300.                     fdl_resp_provide(dev_num, DP_C1_RD_WR_SAP_NR, FDL_PRIMARY_BUF );
  301.                     msac_c1_set_job_running(dev_num, FALSE );
  303.                     dp_sys[dev_num].c1.event &= ~MSAC_C1_IND_DS_WRITE;
  304.                     break;
  305.                 }//case DPV1_OK:
  307.                 case DPV1_NOK:
  308.                 {
  309.                     dpv1_act_pdu_ptr->write.function_num |= DPV1_ERROR_BIT_RESPONSE;
  310.                     dpv1_act_pdu_ptr->neg.err_decode = DPV1_ERRDC_DPV1;
  312.                     dpv1_act_ind_ptr[dev_num]->data_len = DPV1_LEN_NEG_RESPONSE;
  313.                     dpv1_act_ind_ptr[dev_num]->fc       = FC_RESP_L;
  314.                     fdl_resp_provide(dev_num, DP_C1_RD_WR_SAP_NR, FDL_PRIMARY_BUF );
  315.                     msac_c1_set_job_running(dev_num, FALSE );
  317.                     dp_sys[dev_num].c1.event &= ~MSAC_C1_IND_DS_WRITE;
  318.                     break;
  319.                 }//case DPV1_NOK:
  321.                 case DPV1_DELAY:
  322.                 {
  323.                     /* user give pdu later back */
  324.                     dp_sys[dev_num].c1.event &= ~MSAC_C1_IND_DS_WRITE;
  325.                     break;
  326.                 }//case DPV1_DELAY:
  328.                 default:
  329.                 {
  330.                     vpc3_errcb[dev_num].error_code = dp_sys[dev_num].c1.event;
  331.                     vpc3_errcb[dev_num].cn_id      = 0;
  332.                     // *** no further action of dpv1/c2 ***
  333.                     fatal_error(dev_num,_DP_C1, __LINE__, &vpc3_errcb[dev_num]);
  334.                     break;
  335.                 }//default:
  336.             }//switch( user_dpv1_write_req(dev_num,DP_C1_RD_WR_SAP_NR,(DPV1_PTR) dpv1_act_pdu_ptr) )
  337.         }//if( dp_sys[dev_num].c1.event & MSAC_C1_IND_DS_WRITE )
  338.     }//if( dp_sys[dev_num].c1.Operation_Mode == DP_OPMODE_V1 )
  339. }//void msac_c1_process(UBYTE dev_num)
  341. /*---------------------------------------------------------------------------*/
  342. /*                                                                           */
  343. /* UBYTE msac_c1_transmit_delay(UBYTE dev_num,UBYTE sap, UBYTE event, DPV1_RET_VAL status, */
  344. /*                                                             DPV1_PTR pdu) */
  345. /*                                                                           */
  346. /*   function: msac_c1_transmit_delay receives response data from the user.  */
  347. /*             In this function the response data are checked. In dependence */
  348. /*             of the pdu-opcode und the status the length of the data and   */
  349. /*             the function-code is manipulated. Then the dpv1_msc1 transmit */
  350. /*             function is called.                                           */
  351. /*                                                                           */
  352. /*   return codes: DPV1_OK            ( transmit function is called )        */
  353. /*                 DPV1_ERR_NO_JOB    ( no active job               )        */
  354. /*                 DPV1_ERR_INV_PARAM ( invalid parameter           )        */
  355. /*                 DPV1_NO_VALID_SAP  ( invalid sap                 )        */
  356. /*                                                                           */
  357. /*---------------------------------------------------------------------------*/
  358. SECTION_DEF_CommuCode UBYTE msac_c1_transmit_delay(UBYTE dev_num, UBYTE sap, UBYTE event, DPV1_RET_VAL status, DPV1_PTR pdu )
  359. {
  360. DPV1_PTR    dpv1_act_pdu_ptr;
  361. UBYTE       ret_val;
  363.     ret_val = DPV1_OK;
  365.     if( (sap&0xff) == DP_C1_RD_WR_SAP_NR )//2009.11.7
  366.     {
  367.         if( dp_sys[dev_num].c1.active_Job )
  368.         {
  369.             dpv1_act_pdu_ptr = ((DPV1_PTR) &dpv1_act_ind_ptr[dev_num]->user_data[0]);
  371.             switch( status )
  372.             {
  373.                 case DPV1_OK:
  374.                 {
  375.                     if( (event&0xff) == MSAC_C1_IND_DS_WRITE )//2009.11.7
  376.                     {
  377.                         dpv1_act_ind_ptr[dev_num]->data_len = DPV1_LEN_HEAD_DATA;
  378.                         dpv1_act_ind_ptr[dev_num]->fc       = FC_RESP_L;
  379.                         fdl_resp_provide(dev_num, DP_C1_RD_WR_SAP_NR, FDL_PRIMARY_BUF );
  380.                         msac_c1_set_job_running(dev_num, FALSE );
  381.                     }//if( event == MSAC_C1_IND_DS_WRITE )
  382.                     else
  383.                     {
  384.                         dpv1_act_ind_ptr[dev_num]->data_len = DPV1_LEN_HEAD_DATA + BFWORD2BYTE(dpv1_act_pdu_ptr->read.length);
  385.                         dpv1_act_ind_ptr[dev_num]->fc       = FC_RESP_L;
  386.                         fdl_resp_provide(dev_num, DP_C1_RD_WR_SAP_NR, FDL_PRIMARY_BUF );
  387.                         msac_c1_set_job_running(dev_num, FALSE );
  388.                     }//else of if( event == MSAC_C1_IND_DS_WRITE )
  389.                     break;
  390.                 }//case DPV1_OK:
  392.                 case DPV1_NOK:
  393.                 {
  394.                     dpv1_act_pdu_ptr->read.function_num |= DPV1_ERROR_BIT_RESPONSE;
  395.                     dpv1_act_pdu_ptr->neg.err_decode = DPV1_ERRDC_DPV1;
  397.                     dpv1_act_ind_ptr[dev_num]->data_len = DPV1_LEN_NEG_RESPONSE;
  398.                     dpv1_act_ind_ptr[dev_num]->fc       = FC_RESP_L;
  399.                     fdl_resp_provide(dev_num, DP_C1_RD_WR_SAP_NR, FDL_PRIMARY_BUF );
  400.                     msac_c1_set_job_running(dev_num, FALSE );
  401.                     break;
  402.                 }//case DPV1_NOK:
  404.                 default:
  405.                 {
  406.                     ret_val = DPV1_ERR_INV_PARAM;
  407.                     break;
  408.                 }//default:
  409.             }//switch( status )
  410.         }//if( dp_sys[dev_num].c1.active_Job )
  411.         else
  412.         {
  413.             ret_val = DPV1_ERR_NO_JOB;
  414.         }//else of if( dp_sys[dev_num].c1.active_Job )
  415.     }//if( sap == DP_C1_RD_WR_SAP_NR )
  416.     else
  417.     {
  418.         //dummyline for compiler because warning
  419.         pdu = pdu;
  420.         ret_val = DPV1_NO_VALID_SAP;
  421.     }//else of if( sap == DP_C1_RD_WR_SAP_NR )
  422.     return (ret_val);
  423. }//UBYTE msac_c1_transmit_delay(UBYTE dev_num, UBYTE sap, UBYTE event, DPV1_RET_VAL status, DPV1_PTR pdu )
  425. /*--------------------------------------------------------------------------*/
  426. /* function: msac_c1_set_job_running                                        */
  427. /*--------------------------------------------------------------------------*/
  428. SECTION_DEF_CommuCode void msac_c1_set_job_running(UBYTE dev_num, UBYTE running )
  429. {
  430.     if( running )
  431.     {
  432.         dp_sys[dev_num].c1.active_Job = TRUE;
  433.     }//if( running )
  434.     else
  435.     {
  436.         dp_sys[dev_num].c1.active_Job = FALSE;
  438.         if( (dp_sys[dev_num].c1.Start_State == DP_SS_STOP) && (dp_sys[dev_num].c1.Fdl_Closing == FALSE) )
  439.         {
  440.             dp_sys[dev_num].c1.Start_State = DP_SS_IDLE;
  441.         }
  443.         if( dp_sys[dev_num].c1.Start_State == DP_SS_START_AGAIN )
  444.         {
  445.             // open C1-SAPs
  446.             fdl_ind_await(dev_num,DP_C1_RD_WR_SAP_NR);
  447.             dp_sys[dev_num].c1.Start_State=DP_SS_RUN;
  448.         }//if( dp_sys[dev_num].c1.Start_State == DP_SS_START_AGAIN )
  449.     }//else of if( running )
  450. }//void msac_c1_set_job_running(UBYTE dev_num, UBYTE running )
  452. /*--------------------------------------------------------------------------*/
  453. /* function: msac_c1_ind_disable_done                                       */
  454. /*--------------------------------------------------------------------------*/
  455. SECTION_DEF_CommuCode void msac_c1_ind_disable_done(UBYTE dev_num, UBYTE sap_nr, UBYTE ret_val )
  456. {
  457.     if( (sap_nr&0xff) == DP_C1_RD_WR_SAP_NR)//2009.11.7
  458.     {
  459.         if(ret_val != FDL_OK)
  460.         {
  461.             vpc3_errcb[dev_num].error_code = VPC3_MSAC_C1_CLOSE_FAILED;
  462.             fatal_error(dev_num,_DP_C1, __LINE__, &vpc3_errcb[dev_num]);
  463.         }//if(ret_val != FDL_OK)
  465.         dp_sys[dev_num].c1.Fdl_Closing = FALSE;
  466.         dp_sys[dev_num].c1.Start_State = (dp_sys[dev_num].c1.active_Job) ? DP_SS_STOP : DP_SS_IDLE;
  467.     }//if(sap_nr == DP_C1_RD_WR_SAP_NR)
  468. }//void msac_c1_ind_disable_done(UBYTE dev_num, UBYTE sap_nr, UBYTE ret_val )
  470. /*--------------------------------------------------------------------------*/
  471. /* function: msac_c1_check_ind_new_prm_data                                 */
  472. /*--------------------------------------------------------------------------*/
  473. SECTION_DEF_CommuCode UBYTE msac_c1_check_ind_new_prm_data(UBYTE dev_num)
  474. {
  475. UBYTE ret_val;
  477.     ret_val = TRUE;
  479.     switch( VPC3_GET_DP_STATE(dev_num) )
  480.     {
  481.         case WAIT_PRM:
  482.         {
  483.             dp_sys[dev_num].c1.Operation_Mode = msac_c1_get_new_operation_mode(dev_num);
  484.             break;
  485.         }
  487.         case WAIT_CFG:
  488.         {
  489.             dp_sys[dev_num].c1.Operation_Mode = msac_c1_get_new_operation_mode(dev_num);
  490.             if (dp_sys[dev_num].c1.Start_State == DP_SS_RUN)
  491.             {
  492.                 msac_c1_stop(dev_num);
  493.             }
  494.             break;
  495.         }
  497.         case DATA_EX:
  498.         {
  499.             dp_sys[dev_num].c1.Operation_Mode = msac_c1_get_new_operation_mode(dev_num);
  501.             msac_c1_stop(dev_num);
  502.             ret_val=FALSE;  /* avoid user-interaction */
  503.             break;
  504.         }
  505.     }//switch( VPC3_GET_DP_STATE(dev_num) )
  507.     #ifdef DP_ALARM
  508.         set_new_alarm_mode(dev_num);
  509.     #endif // #ifdef DP_ALARM
  511.     return ret_val;
  512. }//UBYTE msac_c1_check_ind_new_prm_data(UBYTE dev_num)
  514. /*--------------------------------------------------------------------------*/
  515. /* function: msac_c1_do_cfg_ok                                              */
  516. /*--------------------------------------------------------------------------*/
  517. SECTION_DEF_CommuCode void msac_c1_do_cfg_ok(UBYTE dev_num)
  518. {
  519.     if( VPC3_GET_DP_STATE(dev_num) == WAIT_CFG )
  520.     {
  521.         if(dp_sys[dev_num].c1.Operation_Mode == DP_OPMODE_V1)
  522.         {
  523.             if( dp_sys[dev_num].c1.Start_State == DP_SS_IDLE )
  524.             {
  525.                 fdl_ind_await(dev_num,DP_C1_RD_WR_SAP_NR);
  526.                 dp_sys[dev_num].c1.Start_State = DP_SS_RUN;
  528.                 #ifdef DP_ALARM_OVER_SAP50
  529.                     fdl_ind_await(dev_num,DP_C1_ALARM_SAP_NR);
  530.                 #endif//#ifdef DP_ALARM_OVER_SAP50
  531.             }
  533.             if( dp_sys[dev_num].c1.Start_State == DP_SS_STOP )
  534.             {
  535.                 dp_sys[dev_num].c1.Start_State = DP_SS_START_AGAIN;
  536.             }
  537.         }
  539.         dp_sys[dev_num].c1.DX_Entered = FALSE;
  540.     }//if( VPC3_GET_DP_STATE(dev_num) == WAIT_CFG )
  541. }//void msac_c1_do_cfg_ok(UBYTE dev_num)
  543. /*--------------------------------------------------------------------------*/
  544. /* function: msac_c1_do_cfg_not_ok                                          */
  545. /*--------------------------------------------------------------------------*/
  546. SECTION_DEF_CommuCode void msac_c1_do_cfg_not_ok(UBYTE dev_num)
  547. {
  548.     switch( VPC3_GET_DP_STATE(dev_num) )
  549.     {
  550.         case WAIT_PRM:
  551.         {
  552.             //do nothing
  553.             break;
  554.         }
  556.         case WAIT_CFG:
  557.         case DATA_EX:
  558.         {
  559.             msac_c1_stop(dev_num);
  560.             break;
  561.         }
  562.     }//switch( VPC3_GET_DP_STATE(dev_num) )
  563. }//void msac_c1_do_cfg_not_ok(UBYTE dev_num)
  565. /*--------------------------------------------------------------------------*/
  566. /* function: msac_c1_check_ind_dx_out                                       */
  567. /*--------------------------------------------------------------------------*/
  568. SECTION_DEF_CommuCode void msac_c1_check_ind_dx_out(UBYTE dev_num)
  569. {
  570.     if(    ( dp_sys[dev_num].c1.DX_Entered     == FALSE        )
  571.         && ( VPC3_GET_DP_STATE(dev_num)      == DATA_EX      )
  572.         && ( dp_sys[dev_num].c1.Operation_Mode == DP_OPMODE_V1 )
  573.       )
  574.     {
  575.         dp_sys[dev_num].c1.DX_Entered = TRUE;
  577.         #ifdef DP_ALARM
  578.             if( dp_sys[dev_num].al.state == AL_STATE_CLOSED )
  579.             {
  580.                 if( dp_sys[dev_num].al.enabled > 0x00 )
  581.                 {
  582.                     dp_sys[dev_num].al.count = 0;
  583.                     dp_sys[dev_num].al.limit = alarm_decode[dev_num][ dp_sys[dev_num].al.mode ];
  584.                     dp_sys[dev_num].al.sequence = (dp_sys[dev_num].al.mode == SEQC_MODE_TOTAL_00 ) ? FALSE : TRUE;
  585.                     dp_sys[dev_num].al.state = AL_STATE_OPEN;
  586.                 }//if( dp_sys[dev_num].al.enabled > 0x00 )
  587.                 else
  588.                 {
  589.                     dp_sys[dev_num].al.enabled = 0;
  590.                     dp_sys[dev_num].al.mode    = 0;
  591.                 }//else of if( dp_sys[dev_num].al.enabled > 0x00 )
  593.                 user_alarm_state_info(dev_num, dp_sys[dev_num].al.enabled, dp_sys[dev_num].al.mode );
  594.             }//if(  dp_sys[dev_num].al.state == AL_STATE_CLOSED  )
  595.         #endif // #ifdef DP_ALARM
  596.     }//if(    (dp_sys[dev_num].c1.DX_Entered     == FALSE        ) ...
  597. }//void msac_c1_check_ind_dx_out(UBYTE dev_num)
  599. /*--------------------------------------------------------------------------*/
  600. /* function: check_sequence_status                                          */
  601. /*--------------------------------------------------------------------------*/
  602. SECTION_DEF_CommuCode MSAC1_OPMODE msac_c1_get_new_operation_mode(UBYTE dev_num)
  603. {
  604. VPC3_UNSIGNED8_PTR prm_data;
  606.     if( VPC3_GET_PRM_LEN(dev_num) >= 10 )
  607.     {
  608.         prm_data = VPC3_GET_PRM_BUF_PTR(dev_num);
  609.         if( prm_data && ( *( prm_data + 7*BLACKFIN_MULTIPLER ) & DPV1_STATUS_1_DPV1_ENABLE ) )
  610.         {
  611.             return DP_OPMODE_V1;
  612.         }
  613.     }//if( VPC3_GET_PRM_LEN(dev_num) >= 10 )
  614.     return DP_OPMODE_V0;
  615. }//MSAC1_OPMODE msac_c1_get_new_operation_mode(UBYTE dev_num)
  617. /*--------------------------------------------------------------------------*/
  618. /* function: msac_c1_leave_dx                                               */
  619. /*--------------------------------------------------------------------------*/
  620. SECTION_DEF_CommuCode void msac_c1_leave_dx(UBYTE dev_num)
  621. {
  622.     if( VPC3_GET_DP_STATE(dev_num) != DATA_EX )
  623.     {
  624.         msac_c1_stop(dev_num);
  626.         if( (vpc3_get_master(dev_num) != 0xFF ) && (VPC3_GET_DP_STATE(dev_num) == WAIT_PRM ) )
  627.         {
  628.             GO_OFFLINE_VPC3(dev_num);
  629.             START_VPC3(dev_num);
  630.         }//if( (vpc3_get_master(dev_num) != 0xFF ) && (VPC3_GET_DP_STATE(dev_num) == WAIT_PRM ) )
  631.     }//if( VPC3_GET_DP_STATE(dev_num) != DATA_EX )
  632. }//void msac_c1_leave_dx(UBYTE dev_num)
  634. // SECTION_DEF_CommuCode void msac_c1_leave_dx_wiscom(UBYTE dev_num)
  635. // {
  636. //  //重新启用一类主站的非周期状态机
  637. //  if(1)
  638. //     {
  639. //         msac_c1_stop(dev_num);
  640. //         if( (vpc3_get_master(dev_num) != 0xFF ))
  641. //         {
  642. //              msac_c1_check_ind_new_prm_data(dev_num);
  643. //              msac_c1_do_cfg_ok(dev_num);
  644. //         
  645. //  //重新启动状态机
  646. //         #ifdef DP_ALARM
  647. //             if( dp_sys[dev_num].al.state == AL_STATE_CLOSED )
  648. //             {
  649. //  dp_sys[dev_num].al.state = AL_STATE_OPEN;
  650. // 
  651. //                 if( dp_sys[dev_num].al.enabled > 0x00 )
  652. //                 {
  653. //                     dp_sys[dev_num].al.count = 0;
  654. //                     dp_sys[dev_num].al.limit = alarm_decode[dev_num][ dp_sys[dev_num].al.mode ];
  655. //                     dp_sys[dev_num].al.sequence = (dp_sys[dev_num].al.mode == SEQC_MODE_TOTAL_00 ) ? FALSE : TRUE;
  656. //                 }//if( dp_sys[dev_num].al.enabled > 0x00 )
  657. //                 else
  658. //                 {
  659. //                     dp_sys[dev_num].al.enabled = 0;
  660. //                     dp_sys[dev_num].al.mode    = 0;
  661. //                 }//else of if( dp_sys[dev_num].al.enabled > 0x00 )
  662. // 
  663. //                 user_alarm_state_info(dev_num, dp_sys[dev_num].al.enabled, dp_sys[dev_num].al.mode );
  664. //             }//if(  dp_sys[dev_num].al.state == AL_STATE_CLOSED  )
  665. //         #endif // #ifdef DP_ALARM
  666. // 
  667. //   
  668. //         }//if( (vpc3_get_master(dev_num) != 0xFF ) && (VPC3_GET_DP_STATE(dev_num) == WAIT_PRM ) )
  669. //     }//if( VPC3_GET_DP_STATE(dev_num) != DATA_EX )
  670. // }//void msac_c1_leave_dx(UBYTE dev_num)
  673. /*--------------------------------------------------------------------------*/
  674. /* function: msac_c1_stop                                                   */
  675. /*--------------------------------------------------------------------------*/
  676. SECTION_DEF_CommuCode void msac_c1_stop(UBYTE dev_num)
  677. {
  678.     dp_sys[dev_num].c1.event = 0x00;
  680.     if( dp_sys[dev_num].c1.Start_State == DP_SS_RUN )
  681.     {
  682.         dp_sys[dev_num].c1.Fdl_Closing = TRUE;
  683.         // close msac_c1
  684.         fdl_ind_disable(dev_num,DP_C1_RD_WR_SAP_NR);
  686.         #ifdef DP_ALARM
  687.             //close ALARM SAP
  688.             stop_asm(dev_num);
  689.         #endif // #ifdef DP_ALARM
  690.     }//if( dp_sys[dev_num].c1.Start_State == DP_SS_RUN )
  691. }//void msac_c1_stop(UBYTE dev_num)
  694. #ifdef DP_ALARM
  695. /*--------------------------------------------------------------------------*/
  696. /* function: init_alarm                                                     */
  697. /*--------------------------------------------------------------------------*/
  698. SECTION_DEF_CommuCode void init_alarm(UBYTE dev_num, UBYTE power_on )
  699. {
  700.     dp_sys[dev_num].al.state   = AL_STATE_CLOSED;
  702.     if( power_on == FALSE )
  703.     {
  704.         user_alarm_state_info(dev_num, ALARM_TYPE_NONE_VALUE, SEQC_MODE_TOTAL_00 );
  705.     }
  707.     dpl_init_list__(&dp_sys[dev_num].al.queue_new);
  708.     dpl_init_list__(&dp_sys[dev_num].al.queue_ack);
  710.     dp_sys[dev_num].al.enabled = 0;
  711.     dp_sys[dev_num].al.mode    = 0;
  713.     dp_sys[dev_num].al.type_status = 0;
  714.     memset( &dp_sys[dev_num].al.sequence_status[0], 0, AL_SEQUENCE_STATUS_SIZE );
  716.     dp_sys[dev_num].al.sequence = 0;
  717.     dp_sys[dev_num].al.limit    = 0;
  718.     dp_sys[dev_num].al.count    = 0;
  720.     // init coding table
  721.     alarm_decode[dev_num][0] = SEQC_MODE_OFF     ;   // no sequence mode - 01 alarm  of every type
  722.     alarm_decode[dev_num][1] = SEQC_MODE_TOTAL_02;   // sequence mode - 02 alarms in total
  723.     alarm_decode[dev_num][2] = SEQC_MODE_TOTAL_04;   // sequence mode - 04 alarms in total
  724.     alarm_decode[dev_num][3] = SEQC_MODE_TOTAL_08;   // sequence mode - 08 alarms in total
  725.     alarm_decode[dev_num][4] = SEQC_MODE_TOTAL_12;   // sequence mode - 12 alarms in total
  726.     alarm_decode[dev_num][5] = SEQC_MODE_TOTAL_16;   // sequence mode - 16 alarms in total
  727.     alarm_decode[dev_num][6] = SEQC_MODE_TOTAL_24;   // sequence mode - 24 alarms in total
  728.     alarm_decode[dev_num][7] = SEQC_MODE_TOTAL_32;   // sequence mode - 32 alarms in total
  729. }//void init_alarm(UBYTE dev_num, UBYTE power_on )
  731. /*--------------------------------------------------------------------------*/
  732. /* function: set_new_alarm_mode                                             */
  733. /*--------------------------------------------------------------------------*/
  734. SECTION_DEF_CommuCode void set_new_alarm_mode(UBYTE dev_num)
  735. {
  736. VPC3_STRUC_PRM_PTR prm_data;
  738.     dp_sys[dev_num].al.enabled = 0;
  739.     dp_sys[dev_num].al.mode    = 0;
  741.     if( (VPC3_GET_PRM_LEN(dev_num) >= PRM_LEN_DPV1 ) && (dp_sys[dev_num].c1.Operation_Mode == DP_OPMODE_V1) )
  742.     {
  743.         prm_data = (VPC3_STRUC_PRM_PTR)VPC3_GET_PRM_BUF_PTR(dev_num);
  744.         if ( prm_data )
  745.         {
  746.             dp_sys[dev_num].al.enabled = (prm_data->dpv1_status_2 & DPV1_STATUS_2_ALARM_TYPE_MASK );
  747.             dp_sys[dev_num].al.mode    = (prm_data->dpv1_status_3 & DPV1_STATUS_3_ALARM_MODE_MASK );
  748.         }
  749.     }
  750. }//void set_new_alarm_mode(UBYTE dev_num)
  752. /*--------------------------------------------------------------------------*/
  753. /* function: alarm_enabled                                                  */
  754. /*--------------------------------------------------------------------------*/
  755. SECTION_DEF_CommuCode UBYTE alarm_enabled(UBYTE dev_num, UBYTE alarm_type )
  756. {
  757.     if(    ((alarm_type == ALARM_TYPE_PULL
  758.         ||   alarm_type == ALARM_TYPE_PLUG)      && (dp_sys[dev_num].al.enabled & ALARM_TYPE_PULLPLUG_VALUE))
  759.         ||  (alarm_type == ALARM_TYPE_PROCESS    && (dp_sys[dev_num].al.enabled & ALARM_TYPE_PROCESS_VALUE))
  760.         ||  (alarm_type == ALARM_TYPE_DIAGNOSTIC && (dp_sys[dev_num].al.enabled & ALARM_TYPE_DIAGNOSTIC_VALUE))
  761.         ||  (alarm_type == ALARM_TYPE_STATUS     && (dp_sys[dev_num].al.enabled & ALARM_TYPE_STATUS_VALUE))
  762.         ||  (alarm_type == ALARM_TYPE_UPDATE     && (dp_sys[dev_num].al.enabled & ALARM_TYPE_UPDATE_VALUE))
  763.         || ((alarm_type >= ALARM_TYPE_MANU_MIN
  764.         &&   alarm_type <= ALARM_TYPE_MANU_MAX)  && (dp_sys[dev_num].al.enabled & ALARM_TYPE_MANUFACTURER_VALUE))
  765.       )
  766.     {
  767.         return TRUE;
  768.     }
  769.     else
  770.     {
  771.         return FALSE;
  772.     }
  773. }//UBYTE alarm_enabled(UBYTE dev_num, UBYTE alarm_type )
  775. /*--------------------------------------------------------------------------*/
  776. /* function: alarm_process                                                  */
  777. /*--------------------------------------------------------------------------*/
  778. SECTION_DEF_CommuCode void alarm_process(UBYTE dev_num)
  779. {
  780. DPV1_PTR    dpv1_act_pdu_ptr;
  782.     // check, if Alarm functions enabled
  783.     if( dp_sys[dev_num].al.state == AL_STATE_OPEN )
  784.     {
  785.         check_send_alarm(dev_num);
  787.         if( dp_sys[dev_num].c1.event & MSAC_C1_IND_ALARM_QUIT )
  788.         {
  789.             dpv1_act_pdu_ptr = ((DPV1_PTR) &dpv1_act_ind_ptr[dev_num]->user_data[0]);
  791.             msac_c1_set_job_running(dev_num, TRUE );
  792.             //switch (dev_num, msac_c1_alarm_quit(dev_num, DP_C1_RD_WR_SAP_NR, dpv1_act_pdu_ptr ) )
  793. switch (msac_c1_alarm_quit(dev_num, DP_C1_RD_WR_SAP_NR, dpv1_act_pdu_ptr ) )
  794.             {
  795.                 case DPV1_OK:
  796.                 {
  797.                     dpv1_act_ind_ptr[dev_num]->data_len = DPV1_LEN_HEAD_DATA;
  798.                     dpv1_act_ind_ptr[dev_num]->fc       = FC_RESP_L;
  799.                     fdl_resp_provide(dev_num, DP_C1_RD_WR_SAP_NR, FDL_PRIMARY_BUF );
  800.                     msac_c1_set_job_running(dev_num, FALSE );
  802.                     dp_sys[dev_num].c1.event &= ~MSAC_C1_IND_ALARM_QUIT;
  803.                     break;
  804.                 }
  806.                 case DPV1_NOK:
  807.                 {
  808.                     msac_c1_set_job_running(dev_num, FALSE );
  809.                     dp_sys[dev_num].al.state = AL_STATE_CLOSED;
  810.                     dp_sys[dev_num].c1.event &= ~MSAC_C1_IND_ALARM_QUIT;
  812. logMsg2("VPC3_SET_USER_LEAVE_MASTER--6!n",0,0,0,0,0,0);
  813.                     VPC3_SET_USER_LEAVE_MASTER(dev_num);
  814.                     break;
  815.                 }
  817.                 case DPV1_DELAY:
  818.                 {
  819.                     dp_sys[dev_num].c1.event &= ~MSAC_C1_IND_ALARM_QUIT;
  820.                     break;
  821.                 }
  823.                 default:
  824.                 {
  825.                     break;
  826.                 }
  827.             }//switch (msac_c1_alarm_quit(dev_num,alarm_sap, dpv1_act_pdu_ptr) )
  828.         }//if( dp_sys[dev_num].c1.event & MSAC_C1_IND_ALARM_QUIT )
  830.         if( dp_sys[dev_num].c1.event & MSAC_C1_IND_ALARM_QUIT_SAP50 )
  831.         {
  832.             dpv1_act_pdu_ptr = ((DPV1_PTR) &dpv1_act_ind_SAP50_ptr[dev_num]->user_data[0]);
  834.             msac_c1_set_job_running(dev_num, TRUE );
  835.             switch (msac_c1_alarm_quit(dev_num, DP_C1_ALARM_SAP_NR, dpv1_act_pdu_ptr ) )
  836.             {
  837.                 case DPV1_OK:
  838.                 {
  839.                     dpv1_act_ind_SAP50_ptr[dev_num]->data_len = DPV1_LEN_HEAD_DATA;
  840.                     dpv1_act_ind_SAP50_ptr[dev_num]->fc       = FC_RESP_L;
  841.                     fdl_resp_provide(dev_num, DP_C1_ALARM_SAP_NR, FDL_PRIMARY_BUF );
  842.                     msac_c1_set_job_running(dev_num, FALSE );
  844.                     dp_sys[dev_num].c1.event &= ~MSAC_C1_IND_ALARM_QUIT_SAP50;
  845.                     break;
  846.                 }
  848.                 case DPV1_NOK:
  849.                 {
  850.                     msac_c1_set_job_running(dev_num, FALSE );
  851.                     dp_sys[dev_num].al.state = AL_STATE_CLOSED;
  852.                     dp_sys[dev_num].c1.event &= ~MSAC_C1_IND_ALARM_QUIT_SAP50;
  854. logMsg("VPC3_SET_USER_LEAVE_MASTER--7!n",0,0,0,0,0,0);
  855.                     VPC3_SET_USER_LEAVE_MASTER(dev_num);
  856.                     break;
  857.                 }
  859.                 case DPV1_DELAY:
  860.                 {
  861.                     dp_sys[dev_num].c1.event &= ~MSAC_C1_IND_ALARM_QUIT_SAP50;
  862.                     break;
  863.                 }
  865.                 default:
  866.                 {
  867.                     break;
  868.                 }
  869.             }//switch (msac_c1_alarm_quit(dev_num,alarm_sap, dpv1_act_pdu_ptr) )
  870.         }//if( dp_sys[dev_num].c1.event & MSAC_C1_IND_ALARM_QUIT_SAP50 )
  871.     }//if( dp_sys[dev_num].al.state == AL_STATE_OPEN )
  872. }//void alarm_process(UBYTE dev_num)
  874. /*--------------------------------------------------------------------------*/
  875. /* function: stop_asm                                                       */
  876. /*--------------------------------------------------------------------------*/
  877. SECTION_DEF_CommuCode void stop_asm(UBYTE dev_num)
  878. {
  879.     //clear alarm message in diagnostic buffer
  880.     reset_diagnostic_buffer(dev_num);
  882. #ifdef DP_ALARM_OVER_SAP50
  883.     fdl_ind_disable(dev_num,DP_C1_ALARM_SAP_NR);
  884. #endif//#ifdef DP_ALARM_OVER_SAP50
  886.     init_alarm(dev_num, FALSE );
  887. }//void stop_asm(UBYTE dev_num)
  889. /*--------------------------------------------------------------------------*/
  890. /* function: acls                                                           */
  891. /*--------------------------------------------------------------------------*/
  892. SECTION_DEF_CommuCode UBYTE acls(UBYTE dev_num,UBYTE alarm_type)
  893. {
  894.     if( alarm_type == ALARM_TYPE_DIAGNOSTIC )
  895.         return 0;
  896.     if( alarm_type == ALARM_TYPE_PROCESS )
  897.         return 1;
  898.     if( alarm_type == ALARM_TYPE_PULL )
  899.         return 2;
  900.     if( alarm_type == ALARM_TYPE_PLUG )
  901.         return 3;
  902.     if( alarm_type == ALARM_TYPE_STATUS )
  903.         return 4;
  904.     if( alarm_type == ALARM_TYPE_UPDATE )
  905.         return 5;
  906.     if( alarm_type >= ALARM_TYPE_MANU_MIN && alarm_type <= ALARM_TYPE_MANU_MAX )
  907.         return 6;
  908.         return 0;//ignore
  909. }//UBYTE acls(UBYTE dev_num,UBYTE alarm_type)
  911. /*--------------------------------------------------------------------------*/
  912. /* function: set_alarm__                                                    */
  913. /*--------------------------------------------------------------------------*/
  914. SECTION_DEF_CommuCode UBYTE set_alarm__(UBYTE dev_num, ALARM_STATUS_PDU_PTR user_alarm_ptr, UBYTE callback )
  915. {
  916. UBYTE seq_nr;
  918.     seq_nr = ((user_alarm_ptr->spec & SEQ_NR_MASK) >> SPEC_SEQ_START);
  920. //     if( dp_sys[dev_num].al.state == AL_STATE_CLOSED )
  921. //  {
  922. //  TRACE("set_alarm__: return SET_ALARM_AL_STATE_CLOSED");
  923. //         return SET_ALARM_AL_STATE_CLOSED;
  924. //  }
  926.     if( alarm_enabled(dev_num, user_alarm_ptr->type ) == FALSE )
  927. {
  928. // TRACE("set_alarm__: return SET_ALARM_ALARMTYPE_NOTSUPP");
  929.         return SET_ALARM_ALARMTYPE_NOTSUPP;
  930. }
  932.     if( (seq_nr&0xff) > MAX_SEQ_NR )//2009.11.7
  933. {
  934. // TRACE("set_alarm__: return SET_ALARM_SEQ_NR_ERROR");
  935.         return SET_ALARM_SEQ_NR_ERROR;
  936. }
  938.     if( (user_alarm_ptr->spec & SPEC_MASK) > 0x03 )
  939. {
  940. // TRACE("set_alarm__: return SET_ALARM_SPECIFIER_ERROR");
  941.         return SET_ALARM_SPECIFIER_ERROR;
  942. }
  944.     user_alarm_ptr->callback = callback;
  945.     dpl_put_blk_to_list_end__(&dp_sys[dev_num].al.queue_new, &user_alarm_ptr->list_head);
  947. logMsg2("DPV1-----step1!n",0,0,0,0,0,0);
  948.     return SET_ALARM_OK;
  949. }//UBYTE set_alarm__(UBYTE dev_num, ALARM_STATUS_PDU_PTR user_alarm_ptr, UBYTE callback )
  951. /*--------------------------------------------------------------------------*/
  952. /* function: check_send_alarm                                               */
  953. /*--------------------------------------------------------------------------*/
  954. SECTION_DEF_CommuCode void check_send_alarm(UBYTE dev_num)
  955. {
  956. ALARM_UNION_ALARM tmp_anchor;
  957. ALARM_UNION_ALARM tmp_alarm;
  958. UBYTE tmp_alarm_specifier;
  959. UBYTE tmp_alarm_callback;
  960. UBYTE tmp_alarm_type;
  961. UBYTE alarm_found;
  963.     tmp_anchor.list_ptr = &dp_sys[dev_num].al.queue_new;
  964.     tmp_alarm .list_ptr =  dp_sys[dev_num].al.queue_new.next_blk_ptr;
  966.     tmp_alarm_specifier = 0;
  967.     tmp_alarm_type      = 0;
  968.     alarm_found         = 0;
  970.     while( (DPL_HOST_PTR_COMPARE_TYPE) tmp_alarm.list_ptr != (DPL_HOST_PTR_COMPARE_TYPE) tmp_anchor.list_ptr )
  971.     {
  972.         tmp_alarm_type      = tmp_alarm.data_ptr->type;
  973.         tmp_alarm_specifier = tmp_alarm.data_ptr->spec;
  974.         tmp_alarm_callback  = tmp_alarm.data_ptr->callback;
  976.         if( dp_sys[dev_num].al.sequence == FALSE )
  977.         {
  978.             //type mode
  979.             //only one alarm of a specific ALARM_TYPE can be active at one time
  980.             if( check_type_status(dev_num, AL_ALARM_STATUS_ACTION_CHECK, tmp_alarm_type ) == FALSE )
  981.             {
  982. logMsg2("DPV1-----step2!n",0,0,0,0,0,0);
  983.                 if( check_send_diag(dev_num, tmp_alarm_type, tmp_alarm.data_ptr, tmp_alarm_callback ) == DP_OK )
  984.                 {
  985. logMsg2("DPV1-----step3!n",0,0,0,0,0,0);
  986.                     check_type_status(dev_num, AL_ALARM_STATUS_ACTION_SET, tmp_alarm_type );
  987.                     check_sequence_status(dev_num, AL_ALARM_STATUS_ACTION_SET, tmp_alarm_type, tmp_alarm_specifier );
  989.                     dpl_remove_blk__(tmp_alarm.list_ptr);
  991.                     tmp_anchor.list_ptr = &dp_sys[dev_num].al.queue_ack;
  993.                     dpl_put_blk_to_list_end__(tmp_anchor.list_ptr, tmp_alarm.list_ptr);
  994.                 }
  995.                 break;
  996.             }//if( check_type_status(dev_num, AL_ALARM_STATUS_ACTION_CHECK, tmp_alarm_type ) == FALSE )
  997.         }//if( alarm_sequence == FALSE )
  998.         else
  999.         {
  1000.             //sequence mode
  1001.             //several alarms (2 to 32) of the same or different ALARM_TYPE can be active at one time
  1002.             if( dp_sys[dev_num].al.sequence == TRUE && dp_sys[dev_num].al.count < dp_sys[dev_num].al.limit )
  1003.             {
  1004.                 check_sequence_status(dev_num, AL_ALARM_STATUS_ACTION_SET, tmp_alarm_type, tmp_alarm_specifier );
  1006.                 dpl_remove_blk__(tmp_alarm.list_ptr);
  1008.                 tmp_anchor.list_ptr = &dp_sys[dev_num].al.queue_ack;
  1010.                 dpl_put_blk_to_list_end__(tmp_anchor.list_ptr, tmp_alarm.list_ptr);
  1012.                 dp_sys[dev_num].al.count++;
  1013.             }
  1014.             else
  1015.             {
  1016.                 //don't send alarm, because limit is reached
  1017.                 break;
  1018.             }
  1019.         }//else of if( alarm_sequence == FALSE )
  1021.         tmp_alarm.list_ptr = tmp_alarm.list_ptr->next_blk_ptr;
  1022.     }//while( (DPL_HOST_PTR_COMPARE_TYPE) tmp_alarm.list_ptr != (DPL_HOST_PTR_COMPARE_TYPE) tmp_anchor.list_ptr )
  1023. }//void check_send_alarm(UBYTE dev_num)
  1025. /*--------------------------------------------------------------------------*/
  1026. /* function: check_send_diag                                                */
  1027. /*--------------------------------------------------------------------------*/
  1028. SECTION_DEF_CommuCode UBYTE check_send_diag(UBYTE dev_num, UBYTE alarm_type, ALARM_STATUS_PDU_PTR alarm_ptr, UBYTE callback )
  1029. {
  1030. VPC3_UNION_DIAG_PTR tmp_diag;
  1031. UBYTE               user_diag[DIAG_BUFSIZE];
  1032. UBYTE               ret_value;
  1034.     if( !VPC3_GET_DIAG_FLAG(dev_num) )
  1035.     {
  1036.         //old diagnostic message is send
  1037.         if( callback == TRUE )
  1038.         {
  1039.             //send alarm over the function user_alarm
  1040.             ret_value = user_alarm(dev_num, alarm_type, alarm_ptr->spec, alarm_ptr, TRUE );
  1041.         }//if( callback == TRUE )
  1042.         else
  1043.         {
  1044.             tmp_diag.byte_ptr = user_diag;
  1045.             memcpy( tmp_diag.byte_ptr, (UBYTE *)&alarm_ptr->header, szAlarmHeader );
  1046.             memcpy( tmp_diag.byte_ptr + szAlarmHeader, alarm_ptr->user_data_ptr, alarm_ptr->header - szAlarmHeader );
  1047.             ret_value = set_diagnosis(dev_num, tmp_diag, alarm_ptr->header, 0x00, TRUE );
  1048.         }//else of if( callback == TRUE )
  1049.     }//if( !VPC3_GET_DIAG_FLAG(dev_num) )
  1050.     else
  1051.     {
  1052.         //wait - old diagnosis is not send
  1053.         ret_value = DP_DIAG_OLD_DIAG_NOT_SEND_ERROR;
  1054.     }//else of if( !VPC3_GET_DIAG_FLAG(dev_num) )
  1055. logMsg("check_send_diag-----ret_value=%02x!n",ret_value,0,0,0,0,0);
  1056.     return ret_value;
  1057. }//UBYTE check_send_diag(UBYTE dev_num, UBYTE alarm_type, ALARM_STATUS_PDU_PTR alarm_ptr, UBYTE callback )
  1059. /*--------------------------------------------------------------------------*/
  1060. /* function: clear_alarm                                                    */
  1061. /*--------------------------------------------------------------------------*/
  1062. SECTION_DEF_CommuCode void clear_alarm(UBYTE dev_num, UBYTE alarm_type_bit_field, UBYTE sequence_number )
  1063. {
  1064. ALARM_UNION_ALARM tmp_anchor;
  1065. ALARM_UNION_ALARM tmp_alarm;
  1066. UBYTE tmp_alarm_specifier;
  1067. UBYTE tmp_alarm_type;
  1068. UBYTE tmp_alarm_type_bit_field;
  1070.     //reset all alarms
  1071.     if( (alarm_type_bit_field == ALARM_TYPE_ALL_VALUE ) && (sequence_number == SEQUENCE_NUMBER_ALL ) )
  1072.     {
  1073.         dpl_init_list__(&dp_sys[dev_num].al.queue_new);
  1074.         dpl_init_list__(&dp_sys[dev_num].al.queue_ack);
  1076.         dp_sys[dev_num].al.type_status = 0;
  1077.         memset( &dp_sys[dev_num].al.sequence_status[0], 0, AL_SEQUENCE_STATUS_SIZE );
  1079.         dp_sys[dev_num].al.count    = 0;
  1080.     }//if( (alarm_type_bit_field == ALARM_TYPE_ALL_VALUE ) && (sequence_number == SEQUENCE_NUMBER_ALL ) )
  1081.     else
  1082.     {
  1083.         tmp_alarm_type_bit_field = 0;
  1085.         if ( ALARM_TYPE_DIAGNOSTIC_VALUE & (alarm_type_bit_field) )
  1086.         {
  1087.             tmp_alarm_type_bit_field |= (1 << (ALARM_TYPE_DIAGNOSTIC - 1));
  1088.         }
  1089.         if ( ALARM_TYPE_PROCESS_VALUE & (alarm_type_bit_field) )
  1090.         {
  1091.             tmp_alarm_type_bit_field |= (1 << (ALARM_TYPE_PROCESS - 1));
  1092.         }
  1093.         if ( ALARM_TYPE_PULLPLUG_VALUE & (alarm_type_bit_field) )
  1094.         {
  1095.             tmp_alarm_type_bit_field |= (1 << (ALARM_TYPE_PULL - 1)) | (1 << (ALARM_TYPE_PLUG - 1));
  1096.         }
  1097.         if ( ALARM_TYPE_STATUS_VALUE & (alarm_type_bit_field) )
  1098.         {
  1099.             tmp_alarm_type_bit_field |= (1 << (ALARM_TYPE_STATUS - 1));
  1100.         }
  1101.         if ( ALARM_TYPE_UPDATE_VALUE & (alarm_type_bit_field) )
  1102.         {
  1103.             tmp_alarm_type_bit_field |= (1 << (ALARM_TYPE_UPDATE - 1));
  1104.         }
  1105.         if ( ALARM_TYPE_MANUFACTURER_VALUE & (alarm_type_bit_field) )
  1106.         {
  1107.             tmp_alarm_type_bit_field |= (1 << (ALARM_TYPE_MAX - 1));
  1108.         }
  1110.         tmp_anchor.list_ptr = &dp_sys[dev_num].al.queue_new;
  1111.         tmp_alarm .list_ptr =  dp_sys[dev_num].al.queue_new.next_blk_ptr;
  1113.         tmp_alarm_specifier = 0;
  1114.         tmp_alarm_type      = 0;
  1116.         while( (DPL_HOST_PTR_COMPARE_TYPE) tmp_alarm.list_ptr != (DPL_HOST_PTR_COMPARE_TYPE) tmp_anchor.list_ptr )
  1117.         {
  1118.             tmp_alarm_specifier = tmp_alarm.data_ptr->spec;
  1119.             tmp_alarm_type      = tmp_alarm.data_ptr->type;
  1121.             if(    (( tmp_alarm_type_bit_field & (1 << (acls(dev_num,tmp_alarm_type)))   ) || ( alarm_type_bit_field == ALARM_TYPE_ALL_VALUE ) )
  1122.                 && ( ( (tmp_alarm_specifier >> SPEC_SEQ_START) == sequence_number ) || ( sequence_number == SEQUENCE_NUMBER_ALL ) )
  1123.               )
  1124.             {
  1125.                 if( dp_sys[dev_num].al.sequence == FALSE )
  1126.                 {
  1127.                     //type mode
  1128.                     //only one alarm of a specific ALARM_TYPE can be active at one time
  1129.                     check_type_status(dev_num, AL_ALARM_STATUS_ACTION_RESET, tmp_alarm_type );
  1130.                     check_sequence_status(dev_num, AL_ALARM_STATUS_ACTION_RESET, tmp_alarm_type, tmp_alarm_specifier );
  1131.                 }//if( alarm_sequence == FALSE )
  1132.                 else
  1133.                 {
  1134.                     //sequence mode
  1135.                     //several alarms (2 to 32) of the same or different ALARM_TYPE can be active at one time
  1136.                     check_sequence_status(dev_num, AL_ALARM_STATUS_ACTION_RESET, tmp_alarm_type, tmp_alarm_specifier );
  1138.                     dp_sys[dev_num].al.count--;
  1139.                 }//else of if( alarm_sequence == FALSE )
  1140.             }//if(  .....
  1142.             tmp_alarm.list_ptr = tmp_alarm.list_ptr->next_blk_ptr;
  1143.         }//while( (DPL_HOST_PTR_COMPARE_TYPE) tmp_alarm.list_ptr != (DPL_HOST_PTR_COMPARE_TYPE) tmp_anchor.list_ptr )
  1144.     }//else of if( ( alarm_type_bit_field == ALARM_TYPE_ALL_VALUE ) && ( sequence_number == SEQUENCE_NUMBER_ALL ) )
  1145. }//void clear_alarm(UBYTE dev_num, UBYTE alarm_type_bit_field, UBYTE sequence_number )
  1147. /*--------------------------------------------------------------------------*/
  1148. /* function: check_type_status                                              */
  1149. /*--------------------------------------------------------------------------*/
  1150. SECTION_DEF_CommuCode UBYTE check_type_status(UBYTE dev_num, UBYTE action, UBYTE alarm_type )
  1151. {
  1152. UBYTE ret_value;
  1154.     alarm_type = (UBYTE)(1 << ( acls(dev_num,alarm_type)));
  1156.     if( action == AL_ALARM_STATUS_ACTION_SET )
  1157.     {
  1158.         dp_sys[dev_num].al.type_status |= alarm_type;
  1159.         ret_value = TRUE;
  1160.     }
  1161.     else
  1162.     if( action == AL_ALARM_STATUS_ACTION_RESET )
  1163.     {
  1164.         dp_sys[dev_num].al.type_status &= ~alarm_type;
  1165.         ret_value = FALSE;
  1166.     }
  1167.     else
  1168.     {
  1169.         ret_value = ( dp_sys[dev_num].al.type_status & alarm_type ) ? TRUE : FALSE;
  1170.     }
  1172.     return ret_value;
  1173. }//UBYTE check_type_status(UBYTE dev_num, UBYTE action, UBYTE alarm_type )
  1175. /*--------------------------------------------------------------------------*/
  1176. /* function: check_sequence_status                                          */
  1177. /*--------------------------------------------------------------------------*/
  1178. SECTION_DEF_CommuCode UBYTE check_sequence_status(UBYTE dev_num, UBYTE action, UBYTE alarm_type, UBYTE alarm_specifier )
  1179. {
  1180. VPC3_UNSIGNED8_PTR  tmp_alarm_sequence_status_ptr;
  1181. UBYTE               ret_value;
  1183.     alarm_type = (1 << ( acls(dev_num,alarm_type)));
  1184. //?应是:alarm_type = acls(dev_num,alarm_type);
  1186.     // bit field index in alarm_sequence_status
  1187.     alarm_type = alarm_type * MAX_SEQ_NR + (alarm_specifier >> SPEC_SEQ_START);
  1189.     // bit mask at byte field index in alarm_sequence_status
  1190.     alarm_specifier = (UBYTE)(1 << (alarm_type & 0x07));
  1192.     /* byte field index in alarm_sequence_status */
  1193.     tmp_alarm_sequence_status_ptr = dp_sys[dev_num].al.sequence_status + (alarm_type >> 3);
  1195.     if( *tmp_alarm_sequence_status_ptr & alarm_specifier )
  1196.     {
  1197.         if( action == AL_ALARM_STATUS_ACTION_RESET )
  1198.         {
  1199.             /* reset only if set */
  1200.             *tmp_alarm_sequence_status_ptr &= ~alarm_specifier;
  1201.         }
  1203.         ret_value = TRUE;
  1204.     }
  1205.     else
  1206.     {
  1207.         if( action == AL_ALARM_STATUS_ACTION_SET )
  1208.         {
  1209.             /* set only if reset */
  1210.             *tmp_alarm_sequence_status_ptr |= alarm_specifier;
  1211.         }
  1213.         ret_value = FALSE;
  1214.     }
  1216.     return(ret_value );
  1217. }//UBYTE check_sequence_status(UBYTE dev_num, UBYTE action, UBYTE alarm_type, UBYTE alarm_specifier )
  1219. /*--------------------------------------------------------------------------*/
  1220. /* msac_c1_alarm_quit (UBYTE dev_num,called by DPV1)                                      */
  1221. /*--------------------------------------------------------------------------*/
  1222. SECTION_DEF_CommuCode DPV1_RET_VAL msac_c1_alarm_quit(UBYTE dev_num, UBYTE sap, DPV1_PTR pdu )
  1223. {
  1224. ALARM_UNION_ALARM   tmp_anchor;
  1225. ALARM_UNION_ALARM   tmp_alarm;
  1226. DPV1_RET_VAL        ret_value;
  1227. UBYTE               tmp_alarm_specifier;
  1228. UBYTE               tmp_alarm_slot_nr;
  1229. UBYTE               tmp_alarm_type;
  1230. UBYTE               alarm_found;
  1231. UBYTE               alarm_type;
  1232. UBYTE               slot_nr;
  1233. UBYTE               seq_nr;
  1235.     ret_value = DPV1_OK;
  1237.     if( ( (sap&0xff) == DP_C1_RD_WR_SAP_NR) || ( (sap&0xff) == DP_C1_ALARM_SAP_NR))
  1238.     {
  1239.         slot_nr    = BFWORD2BYTE(pdu->alarm.slot_num);
  1240.         alarm_type = BFWORD2BYTE(pdu->alarm.alarm_type);
  1241.         seq_nr     = (pdu->alarm.specifier & SEQ_NR_MASK) >> SPEC_SEQ_START;
  1243.         tmp_anchor.list_ptr = &dp_sys[dev_num].al.queue_ack;
  1244.         tmp_alarm .list_ptr =  dp_sys[dev_num].al.queue_ack.next_blk_ptr;
  1246.         tmp_alarm_specifier = 0;
  1247.         tmp_alarm_slot_nr   = 0;
  1248.         tmp_alarm_type      = 0;
  1249.         alarm_found         = FALSE;
  1251.         while( (DPL_HOST_PTR_COMPARE_TYPE) tmp_alarm.list_ptr != (DPL_HOST_PTR_COMPARE_TYPE) tmp_anchor.list_ptr )
  1252.         {
  1253. logMsg2("DPV1-----step5!n",0,0,0,0,0,0);
  1254.             tmp_alarm_specifier = tmp_alarm.data_ptr->spec;
  1255.             tmp_alarm_slot_nr   = tmp_alarm.data_ptr->slot;
  1256.             tmp_alarm_type      = tmp_alarm.data_ptr->type;
  1258.             if(    ((tmp_alarm_specifier & SEQ_NR_MASK) >> SPEC_SEQ_START == seq_nr     )
  1259.                 && ( tmp_alarm_type                                       == alarm_type )
  1260.                 && ( tmp_alarm_slot_nr                                    == slot_nr    )
  1261.               )
  1262.             {
  1263.                 //alarm found
  1264.                 alarm_found = TRUE;
  1265.                 break;
  1266.             }
  1268.             tmp_alarm.list_ptr = tmp_alarm.list_ptr->next_blk_ptr;
  1269.         }//while( (DPL_HOST_PTR_COMPARE_TYPE) tmp_alarm.list_ptr != (DPL_HOST_PTR_COMPARE_TYPE) tmp_anchor.list_ptr )
  1271.         if( alarm_found == TRUE )
  1272.         {
  1273. logMsg2("DPV1-----step6!n",0,0,0,0,0,0);
  1274.             if( dp_sys[dev_num].al.sequence == FALSE )
  1275.             {
  1276.                 //type mode
  1277.                 //only one alarm of a specific ALARM_TYPE can be active at one time
  1278.                 check_type_status(dev_num, AL_ALARM_STATUS_ACTION_RESET, tmp_alarm_type );
  1279.                 check_sequence_status(dev_num, AL_ALARM_STATUS_ACTION_RESET, tmp_alarm_type, tmp_alarm_specifier );
  1280.             }//if( alarm_sequence == FALSE )
  1281.             else
  1282.             {
  1283.                 //sequence mode
  1284.                 //several alarms (2 to 32) of the same or different ALARM_TYPE can be active at one time
  1285.                 check_sequence_status(dev_num, AL_ALARM_STATUS_ACTION_RESET, tmp_alarm_type, tmp_alarm_specifier );
  1287.                 dp_sys[dev_num].al.count--;
  1288.             }//else of if( alarm_sequence == FALSE )
  1290.             dpl_remove_blk__(tmp_alarm.list_ptr );
  1292.             user_alarm_ack_req(dev_num, tmp_alarm.data_ptr );
  1293.         }//if( alarm_found == TRUE )
  1294.         else
  1295.         {
  1296. logMsg2("msac_c1_alarm_quit----DPV1_NOK--1!n",0,0,0,0,0,0);
  1297.             ret_value = DPV1_NOK;
  1298.         }//else of if( alarm_found == TRUE )
  1299.     }
  1300.     else
  1301.     {
  1302. logMsg2("msac_c1_alarm_quit----DPV1_NOK--2!n",0,0,0,0,0,0);
  1303.         return DPV1_NOK;
  1304.     }
  1306.     return ret_value;
  1307. }//DPV1_RET_VAL msac_c1_alarm_quit(UBYTE dev_num,UBYTE sap, DPV1_PTR pdu)
  1309. //wusenlin 增加用于报警状态机在通断电情况下报警超时时取消报警
  1310. SECTION_DEF_CommuCode int msac_c1_alarm_quit_wiscom(UBYTE dev_num, UBYTE sap, 
  1311. UBYTE slot_nr, UBYTE  alarm_type, UBYTE seq_nr)
  1312. {
  1313. #define TYPE_QUIT_LEAVEMASTER 
  1315. //ALARM_UNION_ALARM   tmp_anchor;
  1316. //ALARM_UNION_ALARM   tmp_alarm;
  1317. DPV1_RET_VAL        ret_value;
  1318. //UBYTE               tmp_alarm_specifier;
  1319. //UBYTE               tmp_alarm_slot_nr;
  1320. //UBYTE               tmp_alarm_type;
  1321. //UBYTE               alarm_found;
  1323.     msac_c1_set_job_running(dev_num, TRUE );
  1325.     ret_value = DPV1_OK;
  1327. #ifdef TYPE_QUIT_LEAVEMASTER
  1329. //直接退出状态机
  1330. VPC3_SET_USER_LEAVE_MASTER(dev_num);
  1332. //重新启动状态机
  1333. if( dp_sys[dev_num].al.state == AL_STATE_CLOSED )
  1334. {
  1335. dp_sys[dev_num].al.state = AL_STATE_OPEN;
  1337. if( dp_sys[dev_num].al.enabled > 0x00 )
  1338. {
  1339. dp_sys[dev_num].al.count = 0;
  1340. dp_sys[dev_num].al.limit = alarm_decode[dev_num][ dp_sys[dev_num].al.mode ];
  1341. dp_sys[dev_num].al.sequence = (dp_sys[dev_num].al.mode == SEQC_MODE_TOTAL_00 ) ? FALSE : TRUE;
  1342. }//if( dp_sys[dev_num].al.enabled > 0x00 )
  1343. else
  1344. {
  1345. dp_sys[dev_num].al.enabled = 0;
  1346. dp_sys[dev_num].al.mode    = 0;
  1347. }//else of if( dp_sys[dev_num].al.enabled > 0x00 )
  1349. user_alarm_state_info(dev_num, dp_sys[dev_num].al.enabled, dp_sys[dev_num].al.mode );
  1350. }//if(  dp_sys[dev_num].al.state == AL_STATE_CLOSED  )
  1352. #else
  1354.     if( ( (sap&0xff) == DP_C1_RD_WR_SAP_NR) || ( (sap&0xff) == DP_C1_ALARM_SAP_NR))//2009.11.7
  1355.     {
  1356. //         slot_nr    = BFWORD2BYTE(pdu->alarm.slot_num);
  1357. //         alarm_type = BFWORD2BYTE(pdu->alarm.alarm_type);
  1358. //         seq_nr     = (pdu->alarm.specifier & SEQ_NR_MASK) >> SPEC_SEQ_START;
  1360.         tmp_anchor.list_ptr = &dp_sys[dev_num].al.queue_ack;
  1361.         tmp_alarm .list_ptr =  dp_sys[dev_num].al.queue_ack.next_blk_ptr;
  1363.         tmp_alarm_specifier = 0;
  1364.         tmp_alarm_slot_nr   = 0;
  1365.         tmp_alarm_type      = 0;
  1366.         alarm_found         = FALSE;
  1368.         while( (DPL_HOST_PTR_COMPARE_TYPE) tmp_alarm.list_ptr != (DPL_HOST_PTR_COMPARE_TYPE) tmp_anchor.list_ptr )
  1369.         {
  1370. logMsg2("DPV1-----step5!n",0,0,0,0,0,0);
  1371.             tmp_alarm_specifier = tmp_alarm.data_ptr->spec;
  1372.             tmp_alarm_slot_nr   = tmp_alarm.data_ptr->slot;
  1373.             tmp_alarm_type      = tmp_alarm.data_ptr->type;
  1375.             if(    ((tmp_alarm_specifier & SEQ_NR_MASK) >> SPEC_SEQ_START == (seq_nr & SEQ_NR_MASK) >> SPEC_SEQ_START     )
  1376.                 && ( tmp_alarm_type                                       == alarm_type )
  1377.                 && ( tmp_alarm_slot_nr                                    == slot_nr    )
  1378.               )
  1379.             {
  1380.                 //alarm found
  1381.                 alarm_found = TRUE;
  1382.                 break;
  1383.             }
  1385.             tmp_alarm.list_ptr = tmp_alarm.list_ptr->next_blk_ptr;
  1386.         }//while( (DPL_HOST_PTR_COMPARE_TYPE) tmp_alarm.list_ptr != (DPL_HOST_PTR_COMPARE_TYPE) tmp_anchor.list_ptr )
  1388.         if( alarm_found == TRUE )
  1389.         {
  1390. logMsg2("DPV1-----step6!n",0,0,0,0,0,0);
  1391.             if( dp_sys[dev_num].al.sequence == FALSE )
  1392.             {
  1393.                 //type mode
  1394.                 //only one alarm of a specific ALARM_TYPE can be active at one time
  1395.                 check_type_status(dev_num, AL_ALARM_STATUS_ACTION_RESET, tmp_alarm_type );
  1396.                 check_sequence_status(dev_num, AL_ALARM_STATUS_ACTION_RESET, tmp_alarm_type, tmp_alarm_specifier );
  1397.             }//if( alarm_sequence == FALSE )
  1398.             else
  1399.             {
  1400.                 //sequence mode
  1401.                 //several alarms (2 to 32) of the same or different ALARM_TYPE can be active at one time
  1402.                 check_sequence_status(dev_num, AL_ALARM_STATUS_ACTION_RESET, tmp_alarm_type, tmp_alarm_specifier );
  1404.                 dp_sys[dev_num].al.count--;
  1405.             }//else of if( alarm_sequence == FALSE )
  1407.             dpl_remove_blk__(tmp_alarm.list_ptr );
  1410. TRACE("msac_c1_alarm_quit_wiscom OK");
  1411.             //user_alarm_ack_req(dev_num, tmp_alarm.data_ptr );
  1412.         }//if( alarm_found == TRUE )
  1413.         else
  1414.         {
  1415. //重新启动状态机
  1416.             if( dp_sys[dev_num].al.state == AL_STATE_CLOSED )
  1417.             {
  1418. dp_sys[dev_num].al.state = AL_STATE_OPEN;
  1420.                 if( dp_sys[dev_num].al.enabled > 0x00 )
  1421.                 {
  1422.                     dp_sys[dev_num].al.count = 0;
  1423.                     dp_sys[dev_num].al.limit = alarm_decode[dev_num][ dp_sys[dev_num].al.mode ];
  1424.                     dp_sys[dev_num].al.sequence = (dp_sys[dev_num].al.mode == SEQC_MODE_TOTAL_00 ) ? FALSE : TRUE;
  1425.                 }//if( dp_sys[dev_num].al.enabled > 0x00 )
  1426.                 else
  1427.                 {
  1428.                     dp_sys[dev_num].al.enabled = 0;
  1429.                     dp_sys[dev_num].al.mode    = 0;
  1430.                 }//else of if( dp_sys[dev_num].al.enabled > 0x00 )
  1432.                 user_alarm_state_info(dev_num, dp_sys[dev_num].al.enabled, dp_sys[dev_num].al.mode );
  1433.             }//if(  dp_sys[dev_num].al.state == AL_STATE_CLOSED  )
  1435. TRACE("msac_c1_alarm_quit_wiscom NOK1");
  1436.             ret_value = DPV1_NOK;
  1437.         }//else of if( alarm_found == TRUE )
  1438.     }
  1439.     else
  1440.     {
  1441. TRACE("msac_c1_alarm_quit_wiscom NOK2");
  1442.         ret_value = DPV1_NOK;
  1443.     }
  1444. #endif//wusenlin
  1449. msac_c1_set_job_running(dev_num, FALSE );
  1451.     return ret_value;
  1452. }//DPV1_RET_VAL msac_c1_alarm_quit(UBYTE dev_num,UBYTE sap, DPV1_PTR pdu)
  1456. #endif//#ifdef DP_ALARM
  1459. #endif //#ifdef DP_MSAC_C1
  1461. /*****************************************************************************/
  1462. /*  Copyright (C) profichip GmbH 2004. Confidential.                         */
  1463. /*****************************************************************************/