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

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

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

开发平台：

C/C++

dp_user.c：源码内容
  1. ///////////////////////////////////////////////////////////////
  2. // 文 件 名 : dp_user.c
  3. // 文件功能 : vpc3用户接口部分
  4. // 作    者 : 530
  5. // 创建时间 : 
  6. // 项目名称 : Blackfin
  7. // 操作系统 : 
  8. // 备    注 :
  9. // 历史记录 : 
  10. ///////////////////////////////////////////////////////////////
  11. #include "......includeLmcInc.h"
  12. #include "..E5_Commu_PtlProfibus.h"
  15. extern void vpc3_neta_isr() ;
  16. extern void vpc3_netb_isr() ; 
  17. extern void show_buffer(UBYTE dev_num,char * msg_ptr, UBYTE * ptr, UWORD length);
  18. extern int msac_c1_alarm_quit_wiscom(UBYTE dev_num, UBYTE sap, 
  19. UBYTE slot_nr, UBYTE  alarm_type, UBYTE seq_nr);
  21. #ifdef DP_TIMESTAMP
  22. /************************************************************************/
  23. /*  时间戳                                                              */
  24. /************************************************************************/
  25. // One-based array of days in year at month start
  26. static const int16 _MonthDays[13] =
  27. {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365};
  29. //判断是否是闰年
  30. /*
  31. 闰年有两种情况，设年份为year，则：
  33. （1）当year是400的整倍数时为闰年，条件表示为：
  35. year%400= =0
  37. （2）当year是4的整倍数，但不是100的整倍数时为闰年，条件为：
  39.     year%4= =0 && year%100 != 0
  40. */
  42. #define IsLeapYear(nYear) ((((nYear) & 3) == 0) && (((nYear) % 100) != 0 || ((nYear) % 400) == 0))
  44. //计算某年某月有多少天
  45. #define GetDaysInMonth(nYear, nMon) (_MonthDays[nMon] - _MonthDays[(nMon)-1] + (((nMon) == 2 && IsLeapYear(nYear)) ? 1 : 0))
  48. ///////////////////////////////////////////////////////////////
  49. // 函 数 名 : _SecondsFromTime
  50. // 函数功能 : 计算dt所对应时间离1900.1.1有多少秒
  51. // 处理过程 : 
  52. // 备    注 : 
  53. // 作    者 : 仲伟
  54. // 时    间 : 2006年1月6日
  55. // 返 回 值 : int32
  56. // 参数说明 : TDateTime dt
  57. ///////////////////////////////////////////////////////////////
  58. // static uint32 _SecondsFromTime(const TDateTime * dt)
  59. // {
  60. //  //计算从1900.1.1到现在有多少天, 2000.1.1为1
  61. //  uint32 nDate = 365L*(dt->y-1900) + (dt->y-1900)/4 - (dt->y-1900)/100 + (dt->y-1900)/400 +
  62. //  _MonthDays[dt->mon-1] + dt->d;
  63. // 
  64. //  //  If leap year and it's before March, subtract 1:
  65. //  if (dt->mon <= 2 && IsLeapYear(dt->y))
  66. //  --nDate;
  67. // 
  68. //  //计算多少秒
  69. //  return (nDate*86400L+3600L*dt->h+60L*dt->min+dt->s);
  70. // }
  72. ///////////////////////////////////////////////////////////////
  73. /// brief     : 从秒得到当前完整时间日期
  74. /// param int32 nS
  75. /// return TFullDateTime
  76. ///
  77. /// author    : 仲伟
  78. /// date      : 2006年12月31日
  79. /// note      : 
  80. ///////////////////////////////////////////////////////////////
  81. static TDateTime _TimeFromSeconds(uint32 nS)
  82. {
  83. TDateTime dt={1900, 1, 1, 0, 0, 0, 0};
  84. uint32 nYDays; //一年多少天
  85. uint32 nYSecs; //一天多少秒
  86. uint32 nMDays;
  88. while (1)
  89. {
  90. //计算本年有多少天，闰年加一天
  91. nYDays = 365 + (IsLeapYear(dt.y)?1:0);
  92. nYSecs = nYDays * 86400L;
  93. if(nYSecs > nS) //大于剩余秒数
  94. {
  95. //时间在本年内
  96. break;
  97. }
  98. else
  99. {
  100. nS -=  nYSecs; //时间进位到下一年
  101. dt.y ++;
  102. }
  103. }
  105. //计算日期
  106. nYDays = nS / 86400L; //本年第几天
  108. for (dt.mon=1;dt.mon<=12;dt.mon++)
  109. {
  110. //计算一个月几天
  111. nMDays = _MonthDays[dt.mon]-_MonthDays[dt.mon-1];
  112. if(dt.mon == 2 && IsLeapYear(dt.y))
  113. {
  114. nMDays ++;
  115. }
  116. if(nYDays>=nMDays)
  117. {
  118. nYDays -= nMDays;
  119. //进入下一个月
  120. }
  121. else
  122. {
  123. //时间就在本月
  124. break;
  125. }
  126. }
  128. dt.d = 1+nYDays; //日
  130. //计算时间
  131. nS %= 86400L;
  132. dt.h = nS / 3600L; //时
  133. nS %= 3600L;
  134. dt.min = nS / 60; //分
  135. dt.s = nS % 60; //秒
  137. return dt;
  138. }
  140. #endif //DP_TIMESTAMP
  143. /*---------------------------------------------------------------------------*/
  144. /* defines, structures                                                       */
  145. /*---------------------------------------------------------------------------*/
  146. // -- defines for user alarm state
  147. #define USER_AL_STATE_CLOSED ((UBYTE)0x00)
  148. #define USER_AL_STATE_OPEN ((UBYTE)0x01)
  149. // -- defines for user state
  150. #define USER_STATE_CLEAR ((UBYTE)0x00)
  151. #define USER_STATE_RUN ((UBYTE)0x01)
  152. // -- defines for diagnostics
  153. #define USER_TYPE_DPV0              ((UBYTE)0xFA)
  154. #define USER_TYPE_PRM_OK            ((UBYTE)0xFB)
  155. #define USER_TYPE_PRM_NOK           ((UBYTE)0xFC)
  156. #define USER_TYPE_CFG_OK            ((UBYTE)0xFD)
  157. #define USER_TYPE_CFG_NOK           ((UBYTE)0xFE)
  158. #define USER_TYPE_APPL_RDY          ((UBYTE)0xFF)
  160. // -- status message data (coded as device diagnosis) -------------------------
  161. // -- Modulstatus -------------------------------------------------------------
  162. typedef struct
  163. {
  164.     UBYTE   sign_len;       // fix to 0x07
  165.     UBYTE   status_type;    // fix to 0x82
  166.     UBYTE   slot_number;    // fix to 0x00
  167.     UBYTE   specifier;      // fix to 0x00
  168.     UBYTE   user_data[2];
  169. } tStatusDiag;
  170. #define sizeof_StatusDiag 6
  172. //SECTION_DEF_CommuData static tStatusDiag status_diag;
  174. #define MaxAlarmLength  64 
  176. typedef struct
  177. {
  178.     UBYTE  state;
  179.     UBYTE  user_diag_active;
  180.     UWORD  old_diag;
  181.     UBYTE  user_diag[DIAG_BUFSIZE];
  182. UWORD event;
  183. UBYTE  DPV1;
  184. UBYTE  application_ready;
  185. CFG_STRUCT  real_cfg; //real cfg data
  187.     struct                   //alarm state machine data
  188.     {
  189.         UBYTE  state;
  190. UBYTE  buffer_used[ALARM_MAX_FIFO];
  191. UBYTE  user_alarm_data[ALARM_MAX_FIFO][MaxAlarmLength];
  192. ALARM_STATUS_PDU alarm_buffers[ALARM_MAX_FIFO];
  193.     }al;
  195. #ifdef DP_FDL
  196. UBYTE  dpv1_rw_buffer[ C1_LEN  ];
  198. #ifdef DPV1_IM_SUPP
  199. UWORD awImIndex[0x10];
  200. #endif//#ifdef DPV1_IM_SUPP
  201. #endif//#ifdef DP_FDL
  202. }USER_STRUC;
  203. static int     g_nPrmCount[2];
  204. static int     g_nCheckCfgCount[2];
  205. static int     g_nC1ReadCount[2];
  206. static int     g_nC1WriteCount[2];
  210. /*---------------------------------------------------------------------------*/
  211. /* global user data definitions                                              */
  212. /*---------------------------------------------------------------------------*/
  213. SECTION_DEF_CommuData VPC3_STRUC_ERRCB                vpc3_errcb[MAX_DEV_NUM]; // error structure
  214. SECTION_DEF_CommuData USER_STRUC                      user[MAX_DEV_NUM];    // user system structure
  216. /*---------------------------------------------------------------------------*/
  217. /* defines, structures and variables for our demo application                */
  218. /*---------------------------------------------------------------------------*/
  220. //default configuration data for startup
  221. //SECTION_DEF_CommuData static UBYTE DefCfg[64] = {0x59,0x17,0x18,0x93,0x93,0x25};//WDZ-5233
  222. //#define CfgDataLength 6
  224. #ifdef DPV1_IM_SUPP
  226. SECTION_DEF_CommuData static ROMCONST__ UBYTE IM_DEFAULT[64] = {  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Header, 10 Octets
  227.       0x00, 0x2A,  // Manufacturer ID, 2 Octets
  228.   0x50, 0x41, 0x30, 0x30, 0x36, 0x33, 0x30, 0x30, 0x20, 0x20, // Order ID, 20 Octets, PA006300
  229.   0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
  230.   0x30, 0x30, 0x30, 0x31, 0x31, 0x32, 0x20, 0x20, 0x20, 0x20, // SerialNumber, 16 Octets, 000112
  231.   0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
  232.   0x00, 0x01, // HardwareRevision, 2 Octets, 1
  233.   0x56, 0x05, 0x00, 0x00, // SoftwareRevision, 4 Octets, V500
  234.   0x00, 0x00, // RevisionCounter 
  235.   0x00, 0x00,  // PROFILE ID, 2 Octets
  236.   0x00, 0x00,  // PROFILE SPECIFIC TYPE, 2 Octets
  237.   0x01, 0x01,  // IM Version, 2 Octets
  238.   0x00, 0x01   // IM Supported, 2 Octets
  239.  };
  241. #endif//#ifdef DPV1_IM_SUPP
  243. // //counter module
  244. // SECTION_DEF_CommuData static UWORD    counter_value[MAX_DEV_NUM];
  245. // SECTION_DEF_CommuData static UBYTE    counter_timebase[MAX_DEV_NUM];
  246. // SECTION_DEF_CommuData static UBYTE    counter_upper_limit[MAX_DEV_NUM];
  247. // SECTION_DEF_CommuData static UBYTE    counter_lower_limit[MAX_DEV_NUM];
  250. #define  MAX_OUTPUT_COUNT  32
  251. #define  MAX_INPUT_COUNT   128
  253. typedef struct
  254. {
  255. UBYTE Data[MAX_OUTPUT_COUNT];
  256. } STRUC_OUTPUT;
  258. typedef struct
  259. {
  260. UBYTE Data[MAX_INPUT_COUNT];
  261. } STRUC_INPUT;
  263. typedef struct
  264. {
  265. UBYTE  NrOfModules;
  266. STRUC_INPUT input;
  267. STRUC_OUTPUT output;
  268. } STRUC_SYSTEM;
  270. SECTION_DEF_CommuData static STRUC_SYSTEM sSystem[MAX_DEV_NUM];
  272. //初始化实际配置
  273. SECTION_DEF_CommuCode static void InitRealCfgData(UBYTE dev_num)
  274. {
  275. uint8* pRealCfgBuff;
  276. uint8 nRealCfgLen;
  277. pRealCfgBuff = GetRealCfgBuffer(dev_num, &nRealCfgLen);
  279. user[dev_num].real_cfg.length = nRealCfgLen; 
  280. memcpy( &user[dev_num].real_cfg.cfg_data[0], &pRealCfgBuff[0], user[dev_num].real_cfg.length );
  281. }
  283. //组装周期性输入数据
  284. SECTION_DEF_CommuCode static void AssembleInput(UBYTE dev_num)
  285. {
  286. int i;
  287. uint8 nUserInputLen;
  288.     uint8* pDataSrc = GetInputBuffer(dev_num, &nUserInputLen);
  290.   UBYTE *pData = sSystem[dev_num].input.Data;
  292. for (i=0; i<nUserInputLen; i++)
  293. {
  294. pData[i] = pDataSrc[i];
  295. }
  296. SendProcess(dev_num,nUserInputLen);
  298. user[dev_num].event |= VPC3_EV_NEW_INPUT_DATA;
  299. }
  302. /*--------------------------------------------------------------------------*/
  303. /* user_alarm_init function                                                 */
  304. /*--------------------------------------------------------------------------*/
  305. SECTION_DEF_CommuCode void user_alarm_init(UBYTE dev_num)
  306. {
  307.     memset(&user[dev_num].al.buffer_used[0], 0, ALARM_MAX_FIFO );
  308. }
  310. /*--------------------------------------------------------------------------*/
  311. /* user_alarm_alloc function                                                */
  312. /*--------------------------------------------------------------------------*/
  313. SECTION_DEF_CommuCode ALARM_STATUS_PDU_PTR user_alarm_alloc(UBYTE dev_num)
  314. {
  315. ALARM_STATUS_PDU_PTR ptr;
  316. UBYTE                i;
  317.     
  318.     ptr = NULL;
  319.     for( i = 0; i < ALARM_MAX_FIFO; i++ )
  320.     {
  321.         if(user[dev_num].al.buffer_used[i] == FALSE)
  322.         {
  323.             ptr = &(user[dev_num].al.alarm_buffers[i]);
  324.             user[dev_num].al.buffer_used[i] = TRUE;
  325.             ptr->header        = 0;
  326.             ptr->type          = 0;
  327.             ptr->slot          = 0;
  328.             ptr->spec          = 0;
  329.             ptr->user_data_len = 0;
  330.             ptr->user_data_ptr = &(user[dev_num].al.user_alarm_data[i][0]);
  331.             break;
  332.         }
  333.     }
  334.     return ptr;
  335. }
  337. /*--------------------------------------------------------------------------*/
  338. /* user_free_alarm_buffer function                                          */
  339. /*--------------------------------------------------------------------------*/
  340. SECTION_DEF_CommuCode void user_free_alarm_buffer(UBYTE dev_num,ALARM_STATUS_PDU_PTR alarm_ptr)
  341. {
  342. ALARM_STATUS_PDU_PTR ptr;
  343. UBYTE                i;
  345.     for( i = 0; i <= ALARM_MAX_FIFO; i++ )
  346.     {
  347.         if( user[dev_num].al.buffer_used[i] == TRUE )
  348.         {
  349. ptr = &(user[dev_num].al.alarm_buffers[i]);
  350.             if( ptr == alarm_ptr )
  351.             {
  352. user[dev_num].al.buffer_used[i] = FALSE;
  353. break;
  354. }
  355.         }
  356.     }
  357. }
  359. /*---------------------------------------------------------------------------*/
  360. /* function: user_alarm (is also called from alarm state machine !!!! )     */
  361. /*---------------------------------------------------------------------------*/
  362. SECTION_DEF_CommuCode UBYTE user_alarm(UBYTE dev_num, UBYTE alarm_type, UBYTE seq_nr, ALARM_STATUS_PDU_PTR alarm_ptr, UBYTE check_diag_flag )
  363. {
  364. VPC3_UNION_DIAG_PTR tmp_diag;
  365. UBYTE  ret_value;
  366. UBYTE               ext_diag;
  367. UBYTE               len_diag;
  368. UBYTE  error;
  369. UWORD  diag;
  371.     ret_value = 0x00;
  373. diag = ((UWORD)(alarm_type << 8) | ((UWORD)seq_nr) );
  375.     if((diag != user[dev_num].old_diag) && (FALSE == user[dev_num].user_diag_active))
  376.     {
  377.         memset( &user[dev_num].user_diag[0], 0x00, sizeof( user[dev_num].user_diag ) );
  378.         tmp_diag.byte_ptr = user[dev_num].user_diag;
  380.         ext_diag = 0x00;
  381.         len_diag = 0x00;
  382.         
  383.         switch( alarm_type )
  384.         {
  385.             case USER_TYPE_CFG_OK:
  386.             {
  387.                 //ext_diag = STAT_DIAG_SET;
  388.                 break;
  389.             }
  391.             case USER_TYPE_CFG_NOK:
  392.             {
  393.                 //modul_status diagnose
  394.                 //memcpy( tmp_diag.byte_ptr, &status_diag.sign_len, sizeof_StatusDiag );
  395.                 // ext_diag = EXT_DIAG_SET;
  396.                 //len_diag = sizeof_StatusDiag;
  397.                 break;
  398.             }
  400.             case ALARM_TYPE_DIAGNOSTIC:
  401.             {
  402. //                ext_diag = EXT_DIAG_SET;                
  403.                 memcpy( tmp_diag.byte_ptr+len_diag, (UBYTE *)&alarm_ptr->header, szAlarmHeader );
  404.                 len_diag += szAlarmHeader;
  405.                 memcpy( tmp_diag.byte_ptr+len_diag, alarm_ptr->user_data_ptr, alarm_ptr->user_data_len );
  406.                 len_diag += alarm_ptr->user_data_len;
  407.                 break;
  408.             }
  409.             case ALARM_TYPE_PROCESS: //增加过程报警类型
  410.             {
  411. //                ext_diag = EXT_DIAG_SET;                
  412.                 memcpy( tmp_diag.byte_ptr+len_diag, (UBYTE *)&alarm_ptr->header, szAlarmHeader );
  413.                 len_diag += szAlarmHeader;
  414.                 memcpy( tmp_diag.byte_ptr+len_diag, alarm_ptr->user_data_ptr, alarm_ptr->user_data_len );
  415.                 len_diag += alarm_ptr->user_data_len;
  416.                 break;
  417.             }
  419.             case USER_TYPE_DPV0:
  420.             {
  421. // ext_diag = EXT_DIAG_SET;
  422. memcpy( tmp_diag.byte_ptr+len_diag, (UBYTE *)&alarm_ptr->header, szAlarmHeader );
  423. len_diag += szAlarmHeader;
  424. memcpy( tmp_diag.byte_ptr+len_diag, alarm_ptr->user_data_ptr, alarm_ptr->user_data_len );
  425. len_diag += alarm_ptr->user_data_len;
  426.              break;
  427.             }
  428.             
  429.          case USER_TYPE_APPL_RDY:
  430.             case USER_TYPE_PRM_NOK:
  431.             case USER_TYPE_PRM_OK:
  432.             default:
  433.             {
  434.                 ext_diag = 0x00;
  435.                 len_diag = 0x00;
  436.                 break;
  437.             }
  438.         }
  440.         user[dev_num].user_diag_active = TRUE;
  441.             
  442.         error = set_diagnosis(dev_num, tmp_diag, len_diag, ext_diag, check_diag_flag  );
  444.         if( error == DP_OK )
  445.         {
  446.             user[dev_num].old_diag = diag;
  447.             if( alarm_type >= USER_TYPE_PRM_OK )
  448.             {
  449.                 user[dev_num].user_diag_active = FALSE;
  450.             }
  451.             ret_value = DP_OK;
  452.         }
  453.         else
  454.         {
  455.          user[dev_num].user_diag_active = FALSE;
  456.             ret_value = error;
  457.         }
  458.     }
  460.     return ret_value;
  461. }
  463. SECTION_DEF_CommuCode UBYTE user_demo_diagnostic(UBYTE dev_num)
  464. {
  465. static UBYTE diagnostic_alarm_seq_nr;
  466. ALARM_STATUS_PDU_PTR p_alarm;
  467. UBYTE ret_value;
  468. UBYTE callback;
  470. UBYTE diag_nr = 1;//test diagnostic
  471. uint8 *pData;
  473. ret_value = TRUE;
  474. p_alarm = user_alarm_alloc(dev_num);
  475.     if( p_alarm != NULL )
  476.     {
  477.      callback = FALSE;
  478. switch(diag_nr) 
  479. {
  480. case 0:
  481. case 1:
  482. diagnostic_alarm_seq_nr = (diagnostic_alarm_seq_nr + 1) & (MAX_SEQ_NR - 1);
  483. p_alarm->header         = szAlarmHeader + 10; //假设10个用户诊断数据
  484. p_alarm->type           = ALARM_TYPE_DIAGNOSTIC;
  485. p_alarm->slot           = 1;
  486. p_alarm->spec           = (1 == 1)?SPEC_APPEARS:SPEC_DISAPPEARS;
  487. p_alarm->spec           += (diagnostic_alarm_seq_nr << SPEC_SEQ_START);
  488. p_alarm->user_data_len  = 10;//假设10个用户诊断数据
  489. pData = p_alarm->user_data_ptr;
  491. *(pData + 0) = diag_nr;
  492. *(pData + 1) = 0x02;
  493. *(pData + 2) = 0x03;
  494. *(pData + 3) = 0x04;
  495. *(pData + 4) = 0x05;
  497. callback = TRUE;
  498. break;
  500. default:
  501. break;
  502. }
  503.             
  504.         if(user[dev_num].DPV1)
  505.         {
  506.         if( set_alarm(dev_num, p_alarm, callback ) != SET_ALARM_OK )
  507.             {
  508.                 user_free_alarm_buffer(dev_num, p_alarm );
  509.              ret_value = FALSE;
  510.             }
  511.         }
  512.         else
  513.         {
  514. //user_alarm(dev_num, USER_TYPE_DPV0, p_alarm->spec, p_alarm, FALSE );
  515. if((user_alarm(dev_num, USER_TYPE_DPV0, p_alarm->spec, p_alarm, FALSE )) != DP_OK)
  516. {
  517. ret_value = FALSE;
  518. }
  519.             user_free_alarm_buffer(dev_num, p_alarm );
  520.         }
  521.     }
  523. return ret_value;
  524. }
  526. //组装动作SOE中的测量值信息，返回报文长度
  527. static uint16 _MeasureInSOEMsg(uint8 * pAddr, const TActionSOE * pSoe)
  528. {
  529. uint16 k=0;
  530. int i;
  532. for (i=0;i<NUM_MEASINSOE;i++) {
  533. if(pSoe->measure.Meas[i].MeasType!=MEAS_NONE)
  534. {
  535. //测量值类型
  536. pAddr[k++]=pSoe->measure.Meas[i].MeasType + 1; //测值ID+1
  538. //值L
  539. pAddr[k++]=LOBYTE(pSoe->measure.Meas[i].Measure); 
  540. //值H
  541. pAddr[k++]=HIBYTE(pSoe->measure.Meas[i].Measure);
  542. }
  543. }
  545. return k;
  546. }
  547. SECTION_DEF_CommuCode uint8 SendUserDiagnostic(uint8 dev_num, uint8 nDiagType, const void * pDiagData, uint8 bAlarm)
  548. {
  549. static UBYTE diagnostic_alarm_seq_nr;
  550. ALARM_STATUS_PDU_PTR p_alarm;
  551. UBYTE ret_value;
  552. UBYTE callback;
  553. uint16 nMs;
  555. // uint8 *pData;
  556. const TActionSOE * pActSOE;
  557. const TDigitalSOE * pDISOE;
  558. TDateTime dt;
  559. int nCounter;
  561. ret_value = TRUE;
  562. p_alarm = user_alarm_alloc(dev_num);
  563.     if( p_alarm != NULL )
  564.     {
  565.      callback = FALSE;
  566. switch(nDiagType) 
  567. {
  568. case ALARM_ACTION:
  569. {
  570. nCounter = 0;
  572. pActSOE = (const TActionSOE *)pDiagData;
  573. diagnostic_alarm_seq_nr = (diagnostic_alarm_seq_nr + 1) & (MAX_SEQ_NR - 1);
  574. p_alarm->header         = szAlarmHeader + nCounter; //用户诊断数据长度预留，最后填充
  575. p_alarm->type           = ( user[dev_num].DPV1 == DPV1_STATUS_1_DPV1_ENABLE ) ? ALARM_TYPE_DIAGNOSTIC : STATUS_MESSAGE;//老400V使用诊断报警，照以前方式，500按过程报警上送
  576. p_alarm->slot           = 1;
  577. p_alarm->spec           = (1)?SPEC_APPEARS:SPEC_DISAPPEARS;
  578. p_alarm->spec           += (diagnostic_alarm_seq_nr << SPEC_SEQ_START);
  579. p_alarm->user_data_len  = nCounter;//用户诊断数据长度预留，最后填充
  580. // pData = p_alarm->user_data_ptr;
  582.                 //用户诊断数据
  583. //11 与GSD文件的诊断块定义对应，value从1开始
  584. p_alarm->user_data_ptr[0] = pActSOE->type;
  585. //12 //预留
  586. p_alarm->user_data_ptr[1] = 0;
  587. //13 //预留
  588. p_alarm->user_data_ptr[2] = 0;
  589. //14 信息类型=1---保护动作
  590. p_alarm->user_data_ptr[3] = 1;
  591. //15 报警状态 1---动作 0---复归
  592. p_alarm->user_data_ptr[4] = 1;
  593. //16 时
  594. p_alarm->user_data_ptr[5] = pActSOE->time.h;
  595. //17 分
  596. p_alarm->user_data_ptr[6] = pActSOE->time.min;
  597. //18 毫秒低字节
  598. //19 毫秒高字节
  599. nMs = pActSOE->time.ms + pActSOE->time.s*1000;
  600. p_alarm->user_data_ptr[7] = LOBYTE(nMs);
  601. p_alarm->user_data_ptr[8] = HIBYTE(nMs);
  602. //SET_WORD_DATA_(&p_alarm->user_data_ptr[7],);
  603. //20 故障相别
  604. p_alarm->user_data_ptr[9] = 0;
  605. //21 故障量个数n≤14
  606. p_alarm->user_data_ptr[10] = 0; //在后面填写故障量个数
  608. //22 故障量1类型
  609. //23 故障量1低字节
  610. //24 故障量1高字节
  611. nCounter = _MeasureInSOEMsg(p_alarm->user_data_ptr + 11, pActSOE);
  613. p_alarm->user_data_ptr[10] = nCounter/3; //在后面填写故障量个数
  615. //长度
  616. p_alarm->user_data_len = 11 + nCounter;
  617. p_alarm->header        = p_alarm->user_data_len+4;
  619. if(!bAlarm)//使用状态消息
  620. p_alarm->type = STATUS_MESSAGE;
  622. callback = TRUE;
  623. }
  624. break;
  625. case ALARM_DI:
  626. {
  627. nCounter = 0;
  629. pDISOE = (const TDigitalSOE *)pDiagData;
  630. diagnostic_alarm_seq_nr = (diagnostic_alarm_seq_nr + 1) & (MAX_SEQ_NR - 1);
  631. p_alarm->header         = szAlarmHeader + nCounter; //用户诊断数据长度预留，最后填充
  632. p_alarm->type           = ( user[dev_num].DPV1 == DPV1_STATUS_1_DPV1_ENABLE ) ? ALARM_TYPE_DIAGNOSTIC : STATUS_MESSAGE;
  633. p_alarm->slot           = 1;
  634. p_alarm->spec           = (pDISOE->state)?SPEC_APPEARS:SPEC_DISAPPEARS;
  635. p_alarm->spec           += (diagnostic_alarm_seq_nr << SPEC_SEQ_START);
  636. p_alarm->user_data_len  = nCounter;//用户诊断数据长度预留，最后填充
  637. // pData = p_alarm->user_data_ptr;
  639.                 //用户诊断数据
  640. //11 与GSD文件的诊断块定义对应，value从1开始
  641. p_alarm->user_data_ptr[0] = pDISOE->type;
  642. //12 //预留
  643. p_alarm->user_data_ptr[1] = pDISOE->di;
  644. //13 //预留
  645. p_alarm->user_data_ptr[2] = 0;
  646. //14 信息类型=2---异常/开入变位
  647. p_alarm->user_data_ptr[3] = 2;
  648. //15 报警状态 1---动作 0---复归
  649. p_alarm->user_data_ptr[4] = pDISOE->state;
  650. //16 时
  651. p_alarm->user_data_ptr[5] = pDISOE->time.h;
  652. //17 分
  653. p_alarm->user_data_ptr[6] = pDISOE->time.min;
  654. //18 毫秒低字节
  655. //19 毫秒高字节
  656. nMs = pDISOE->time.ms + pActSOE->time.s*1000;
  657. p_alarm->user_data_ptr[7] = LOBYTE(nMs);
  658. p_alarm->user_data_ptr[8] = HIBYTE(nMs);
  660. //长度
  661. p_alarm->user_data_len = 9;
  662. p_alarm->header        = p_alarm->user_data_len+4;
  664. if(!bAlarm)//使用状态消息
  665. p_alarm->type = STATUS_MESSAGE;
  667. callback = TRUE;
  668. }
  669. break;
  670. case ALARM_V0_DIAG:
  671. {
  672. diagnostic_alarm_seq_nr = (diagnostic_alarm_seq_nr + 1) & (MAX_SEQ_NR - 1);
  673. p_alarm->header         = szAlarmHeader + MAX_DIAG_DATA_LEN; //用户诊断数据长度
  674. p_alarm->type           = STATUS_MESSAGE;
  675. p_alarm->slot           = 1;
  676. p_alarm->spec           = SPEC_GENERAL + (diagnostic_alarm_seq_nr << SPEC_SEQ_START);
  677. p_alarm->user_data_len  = MAX_DIAG_DATA_LEN;
  678. // pData = p_alarm->user_data_ptr;
  680. memset(p_alarm->user_data_ptr+szAlarmHeader, 0, p_alarm->user_data_len);
  681. memcpy( p_alarm->user_data_ptr, &g_ProfibusRam.V0_DiagData[0], MAX_DIAG_DATA_LEN );
  683. callback = TRUE;
  684. }
  685. break ;
  686. case ALARM_WAVE: //录波通知
  687. {
  688. diagnostic_alarm_seq_nr = (diagnostic_alarm_seq_nr + 1) & (MAX_SEQ_NR - 1);
  689. p_alarm->header         = szAlarmHeader + 4; 
  690. p_alarm->type           = ( user[dev_num].DPV1 == DPV1_STATUS_1_DPV1_ENABLE ) ? ALARM_TYPE_DIAGNOSTIC : STATUS_MESSAGE;
  691. p_alarm->slot           = 1;
  692. p_alarm->spec           = SPEC_APPEARS;
  693. p_alarm->spec           += (diagnostic_alarm_seq_nr << SPEC_SEQ_START);
  694. p_alarm->user_data_len  = 0;
  696.                 //用户诊断数据
  697. //*(pData + 0) = 0x00;
  698. //*(pData + 1) = 0x00;
  699. //*(pData + 2) = 0x00;
  700. //*(pData + 3) = ALARM_WAVE;
  702. //11 
  703. p_alarm->user_data_ptr[0] = 0;
  704. //12 //预留
  705. p_alarm->user_data_ptr[1] = 0;
  706. //13 //预留
  707. p_alarm->user_data_ptr[2] = 0;
  708. //14 
  709. p_alarm->user_data_ptr[3] = ALARM_WAVE;
  711. //TDateTime dtTime; //故障时间，不等于第一区段的时间
  712. //uint16 nFirstFAN; //第一个故障序号（第一个区段的故障序号）
  713. //uint16 nNOF; //电网故障序号
  714. //uint8  nSOF; //故障的状态
  715. dt = WaveRecord.Config.Start[0].Time;
  716. p_alarm->user_data_ptr[4] = LOBYTE(dt.y);
  717. p_alarm->user_data_ptr[5] = HIBYTE(dt.y);
  718. p_alarm->user_data_ptr[6] = dt.mon;
  719. p_alarm->user_data_ptr[7] = dt.d;
  720. p_alarm->user_data_ptr[8] = dt.h;
  721. p_alarm->user_data_ptr[9] = dt.min;
  722. nMs = dt.s * 1000 + dt.ms;
  723. p_alarm->user_data_ptr[10] = LOBYTE(nMs);
  724. p_alarm->user_data_ptr[11] = HIBYTE(nMs);
  725. p_alarm->user_data_ptr[12] = LOBYTE(WaveRecord.wavenumber.fan);
  726. p_alarm->user_data_ptr[13] = HIBYTE(WaveRecord.wavenumber.fan);
  727. p_alarm->user_data_ptr[14] = LOBYTE(WaveRecord.wavenumber.nof );
  728. p_alarm->user_data_ptr[15] = HIBYTE(WaveRecord.wavenumber.nof);
  729. p_alarm->user_data_ptr[16] = LOBYTE(WaveRecord.wavenumber.sof);
  731. //长度
  732. p_alarm->user_data_len = 17;
  733. p_alarm->header        = p_alarm->user_data_len+4;
  735. if(!bAlarm)//使用状态消息
  736. p_alarm->type = STATUS_MESSAGE;
  738. callback = TRUE;
  739. }
  740. break ;
  741. default:
  742. break;
  743. }
  744.         
  745.         if(user[dev_num].DPV1 && bAlarm)//增加只有需要报警时才走报警通道
  746.         {
  747.         if( set_alarm(dev_num, p_alarm, callback ) != SET_ALARM_OK )
  748.             {
  749. //TRACE("set_alarm return not SET_ALARM_OK...");
  751.                 user_free_alarm_buffer(dev_num, p_alarm );
  752.              ret_value = FALSE;
  753.             }
  754.         }
  755.         else
  756.         {
  757. //user_alarm(dev_num, USER_TYPE_DPV0, p_alarm->spec, p_alarm, FALSE );
  758. if((user_alarm(dev_num, USER_TYPE_DPV0, p_alarm->spec, p_alarm, FALSE )) != DP_OK)
  759. {
  760. ret_value = FALSE;
  761. }
  762.             user_free_alarm_buffer(dev_num, p_alarm );
  763.         }
  764.     }
  765. else
  766. {
  767.         //TRACE("user_alarm_alloc return null...");
  769. ret_value = FALSE;
  770. }
  771. return ret_value;
  772. }
  774. SECTION_DEF_CommuCode void read_input_data(UBYTE dev_num)
  775. {
  776. VPC3_UNSIGNED8_PTR  input_buf_ptr;  // pointer to input buffer
  777. int nBlackfinLoop;
  778. uint16* pBlackfinAddr;
  779. // uint16* pSrcAddr;
  781.     // write DIN data to VPC3
  782.     if(input_buf_ptr = vpc3_get_dinbufptr (dev_num))
  783.     {
  784.         //memcpy( input_buf_ptr, sSystem[dev_num].input.Data, dp_sys[dev_num].inp_data_len );
  786. pBlackfinAddr = (uint16*)input_buf_ptr;
  787. for (nBlackfinLoop=0; nBlackfinLoop<dp_sys[dev_num].inp_data_len; nBlackfinLoop++)
  788. {
  789. pBlackfinAddr[nBlackfinLoop] = sSystem[dev_num].input.Data[nBlackfinLoop];
  790. }
  792.         dp_sys[dev_num].vpc3_con = VPC3_INPUT_UPDATE(dev_num);
  793.     }
  794. }
  797. SECTION_DEF_CommuCode void application_ready(UBYTE dev_num)
  798. {
  799. #ifdef DPV1_IM_SUPP
  800. user[dev_num].awImIndex[ 0x03 ] = 0x0000;
  801. #endif//#ifdef DPV1_IM_SUPP
  803.     read_input_data(dev_num);
  804.     user_alarm(dev_num, USER_TYPE_APPL_RDY, 0, (ALARM_STATUS_PDU_PTR) NULL_PTR, FALSE );
  805.     user[dev_num].application_ready = TRUE;
  806. }
  810. SECTION_DEF_CommuCode bool16 InitVPC3(int dev_num, uint8 nAddr)
  811. {
  812. DP_ERROR_CODE error;
  814. //用户数据结构
  815. memset( &user[dev_num], 0, sizeof(USER_STRUC) ); 
  816.     user[dev_num].user_diag_active  = FALSE;
  817. user[dev_num].application_ready = FALSE;
  818.     user[dev_num].state = USER_STATE_CLEAR;
  820.     //VPC3 使用的数据结构
  821. memset( &sSystem[dev_num], 0, sizeof(STRUC_SYSTEM) );
  823. //初始化实际配置信息
  824. InitRealCfgData(dev_num);
  826. //复位芯片
  827. ResetVPC3(dev_num);
  829.     //芯片及协议栈初始化
  830. error = vpc3_initialization(dev_num, nAddr, user[dev_num].real_cfg );
  831.     
  832.     if( DP_OK == error )
  833.     {
  834.          START_VPC3(dev_num);
  835.     }
  836.     else
  837.     {
  838.         vpc3_errcb[dev_num].error_code = error;
  839.         fatal_error(dev_num, _DP_USER, __LINE__, &vpc3_errcb[dev_num] );
  840.     }
  842. return (error == DP_OK);
  843. }
  844. SECTION_DEF_CommuCode int GetProfibusBaudRate(int dev_num)
  845. {
  846.    return VPC3_GET_BAUDRATE(dev_num);
  847. }
  848. SECTION_DEF_CommuCode bool16 IsInDPV1Status(uint8 nDevID)
  849. {
  850. return user[nDevID].DPV1 == DPV1_STATUS_1_DPV1_ENABLE;
  851. }
  852. SECTION_DEF_CommuCode int GetProfibusPrmCount(int dev_num)
  853. {
  854. return g_nPrmCount[dev_num];
  855. }
  856. SECTION_DEF_CommuCode int GetProfibusCheckCfgCount(int dev_num)
  857. {
  858. return g_nCheckCfgCount[dev_num];
  859. }
  860. SECTION_DEF_CommuCode int GetProfibusMasterAddr(int dev_num)
  861. {
  862. return vpc3_get_master(dev_num);
  863. }
  864. SECTION_DEF_CommuCode int GetProfibusDPState(int dev_num)
  865. {
  866. return VPC3_GET_DP_STATE(dev_num);
  867. }
  868. SECTION_DEF_CommuCode int GetProfibusC1ReadCount(int dev_num)
  869. {
  870. return g_nC1ReadCount[dev_num];
  871. }
  872. SECTION_DEF_CommuCode int GetProfibusC1WriteCount(int dev_num)
  873. {
  874. return g_nC1WriteCount[dev_num];
  875. }
  877. /*---------------------------------------------------------------------------*/
  878. /* user main function                                                        */
  879. /*---------------------------------------------------------------------------*/
  880. SECTION_DEF_CommuCode void user_main(int if_num)
  881. {
  882. VPC3_UNSIGNED8_PTR  output_buf_ptr; // pointer to output buffer
  883. // DP_ERROR_CODE error;
  884. UBYTE            outp_state;  // state of output data
  886. UBYTE dev_num = (UBYTE)if_num;
  887. UBYTE               dp_state;  
  888. // UBYTE i=0;
  889.   // UWORD cnt=0;
  891.   int nBlackfinLoop;
  892.  // uint16* pBlackfinAddr;
  893.   uint16* pSrcAddr;
  895. // int nBaudRate = VPC3_GET_BAUDRATE(dev_num) ;
  898.     if( 1 )
  899.     {
  900.         //toggle user watchdog
  901.         VPC3_RESET_USER_WD(dev_num);
  902. vpc3_isr(dev_num);
  904.         if( user[dev_num].state == USER_STATE_CLEAR )
  905.         {
  906.    memset(sSystem[dev_num].input.Data , 0, MAX_INPUT_COUNT);
  907. memset(sSystem[dev_num].output.Data , 0, MAX_OUTPUT_COUNT);
  908.             user[dev_num].state = USER_STATE_RUN;
  909.         }
  911.        vpc3_dpv1_statemachine(dev_num);
  912.        dp_state = VPC3_GET_DP_STATE(dev_num);
  913.   
  914.    switch(dp_state)
  915.        {
  916.             case WAIT_PRM:
  917.             case WAIT_CFG:
  918.             case DP_ERROR:
  919.             {          
  920. if( user[dev_num].event & VPC3_EV_DX_OUT )
  921. {
  922. user[dev_num].event &= ~VPC3_EV_DX_OUT;       // clear event
  923. }
  925. SetDataExchangeLED(FALSE);
  927.                 break;
  928.             }
  929.             case DATA_EX:
  930.             {
  931. if((user[dev_num].application_ready == TRUE) && (user[dev_num].state == USER_STATE_RUN))
  932. {
  933. SetDataExchangeLED(TRUE);
  935. //处理周期性输出
  936. if( user[dev_num].event & VPC3_EV_DX_OUT )
  937. {
  938. user[dev_num].event &= ~VPC3_EV_DX_OUT;
  939.              if( output_buf_ptr = vpc3_get_doutbufptr (dev_num,&outp_state) )
  940.              {
  941.                      //memcpy( sSystem[dev_num].output.Data, output_buf_ptr, dp_sys[dev_num].outp_data_len);
  942. pSrcAddr = (uint16*)output_buf_ptr;
  943. for (nBlackfinLoop=0; nBlackfinLoop<dp_sys[dev_num].outp_data_len; nBlackfinLoop++)
  944. {
  945. sSystem[dev_num].output.Data[nBlackfinLoop] = pSrcAddr[nBlackfinLoop];
  946. }
  947.                  //处理输出数据
  948. SetOutputBuffer(dev_num, sSystem[dev_num].output.Data, dp_sys[dev_num].outp_data_len);
  949. ReceiveProcess(dev_num,dp_sys[dev_num].outp_data_len);
  950.                  }
  951.          }
  952.         
  953.          //处理诊断
  954. AlarmProcess(dev_num);
  956.          //处理输入信息
  957. AssembleInput(dev_num);
  958. if( user[dev_num].event & VPC3_EV_NEW_INPUT_DATA )
  959. {
  960. read_input_data(dev_num);
  961. user[dev_num].event &= ~VPC3_EV_NEW_INPUT_DATA;
  962. }
  964. //其他空闲任务处理
  965. DoEventInDxState(dev_num);
  967. //CS中断
  968. if (user[dev_num].event & VPC3_EV_MAC_RESET)
  969. {
  970. user[dev_num].event &= ~VPC3_EV_MAC_RESET;       // clear event
  972. //print_cs_buffer();
  973. }
  974. }
  976.                 break;
  977.             }
  979.             default:
  980.             {
  981. SetDataExchangeLED(FALSE);
  983.                 vpc3_errcb[dev_num].error_code = VPC3_GET_DP_STATE(dev_num);
  984.                 fatal_error(dev_num, _DP_USER, __LINE__, &vpc3_errcb[dev_num] );
  985.                 break;
  986.             }
  987.         }
  989.         //handle here profibus interrupt events 
  990.      if( user[dev_num].event & VPC3_EV_NEW_CFG_DATA )
  991.      {
  992.          application_ready(dev_num);
  993.          user[dev_num].event &= ~VPC3_EV_NEW_CFG_DATA;
  994.      }
  995.     }
  996. }
  998. /*---------------------------------------------------------------------------*/
  999. /*                                                                           */
  1000. /*   function:     fatal_error                                               */
  1001. /*                                                                           */
  1002. /*---------------------------------------------------------------------------*/
  1003. SECTION_DEF_CommuCode void fatal_error(UBYTE dev_num, DP_ERROR_FILE file, UWORD line, VPC3_ERRCB_PTR errcb_ptr)
  1004. {
  1006. }
  1009. /*---------------------------------------------------------------------------*/
  1010. /* function: user_isr_new_prm_data                                           */
  1011. /*                                                                           */
  1012. /* todo  : check the prm-data                                                */
  1013. /* return: DP_OK  - prm-data OK                                              */
  1014. /*         DP_NOK - prm-data not OK                                          */
  1015. /*---------------------------------------------------------------------------*/
  1016. #if( ISR_ENABLE_VPC3_INT_NEW_PRM_DATA == 1 )
  1017. SECTION_DEF_CommuCode UBYTE user_chk_new_prm_data(UBYTE dev_num, VPC3_UNSIGNED8_PTR prm_ptr, UBYTE len )
  1018. {
  1019. typedef struct
  1020. {
  1021. UBYTE len;
  1022. UBYTE slot_nr;
  1023. UBYTE user_data;
  1024. }STRUC_MODULE_PRM_BLOCK;
  1025. #define VPC3_STRUC_MODULE_PRM_BLOCK_PTR  STRUC_MODULE_PRM_BLOCK PTR_ATTR *
  1027. // VPC3_STRUC_MODULE_PRM_BLOCK_PTR module_block;
  1028. VPC3_STRUC_PRM_PTR  prm_data;
  1029. UBYTE               ret_value;
  1030.     UWORD Clock_Sync_Interval;
  1032. UBYTE i;
  1033. UBYTE theUserPrmDataBuff[64];  
  1035.     user[dev_num].DPV1 = 0x00;
  1037.     ret_value = DP_OK;
  1039. #ifdef DP_TIMESTAMP
  1040. //设置时钟同步报文间隔
  1041.         Clock_Sync_Interval = 100; //10ms单位, 1S校时一次
  1042. p_Vpc3[dev_num]->cs.clock.sync_interval[0] = HIBYTE(Clock_Sync_Interval);
  1043. p_Vpc3[dev_num]->cs.clock.sync_interval[1] = LOBYTE(Clock_Sync_Interval);
  1044. #endif
  1046. if( len == 0x0B )
  1047.     {
  1048. g_nPrmCount[dev_num]++; //参数化计数器 
  1050.         prm_data = (VPC3_STRUC_PRM_PTR)prm_ptr;
  1052.         //DPV1 Statusbyte 1
  1053.         user[dev_num].DPV1 = (prm_data->dpv1_status_1 & DPV1_STATUS_1_DPV1_ENABLE );
  1054. g_ProfibusRam.bDPV1Enable = !!user[dev_num].DPV1;//DPV1启用标志
  1056. if( user[dev_num].DPV1 == DPV1_STATUS_1_DPV1_ENABLE )
  1057. {
  1058. // DPV1 enabled
  1059. if(    (( prm_data->dpv1_status_1 & 0x18 ) != 0x00 )
  1060. || (( prm_data->dpv1_status_2 & 0x03 ) != 0x00 )
  1061. || ((prm_data->dpv1_status_3 & 0xFF ) != 0x00 )
  1062. )
  1063. {
  1064. ret_value = DP_PRM_DPV1_STATUS;
  1065. }
  1066. }//if( user[dev_num].DPV1 == DPV1_STATUS_1_DPV1_ENABLE )
  1067. else
  1068. {
  1069. //DP-Mode
  1070. if(    (( prm_data->dpv1_status_1 & 0x18 ) != 0x00 )
  1071. || (( prm_data->dpv1_status_2 & 0xFF ) != 0x00 )
  1072. || (( prm_data->dpv1_status_3 & 0xFF ) != 0x00 )
  1073. )
  1074. {
  1075. ret_value = DP_PRM_DPV1_STATUS;
  1076. }
  1077. }//else of if( user[dev_num].DPV1 == DPV1_STATUS_1_DPV1_ENABLE )
  1080. //用户参数化数据
  1081. for(i=0; i<len-10; i++)
  1082. {
  1083. theUserPrmDataBuff[i] = *( ((BLACKFINDATATYPE*)&prm_data->user_data) + i);
  1084. }
  1086. //检查用户参数化数据
  1087. if(SetPrmBuffer(dev_num, theUserPrmDataBuff, len-10))
  1088. {
  1089. ret_value = DP_OK;
  1090. }
  1091. else
  1092. {
  1093. ret_value = DP_NOK;
  1094. }
  1095.     }
  1096.     else
  1097.     {
  1098.         ret_value = DP_PRM_LEN_ERROR;
  1099.     }
  1101.     if( ( VPC3_GET_DP_STATE(dev_num) == DATA_EX ) && (ret_value == DP_OK ) )
  1102.     {
  1103.         //don't send diagnostic here
  1104.     }
  1105.     else
  1106.     {
  1107.         user_alarm(dev_num, USER_TYPE_PRM_OK, 0, (ALARM_STATUS_PDU_PTR) NULL_PTR, FALSE );
  1108.     }
  1110. return ret_value;
  1111. }
  1112. #endif
  1114. /*---------------------------------------------------------------------------*/
  1115. /* function: user_isr_new_ext_prm_data                                       */
  1116. /*                                                                           */
  1117. /* todo  : check the prm-data                                                */
  1118. /* return: DP_OK  - prm-data OK                                              */
  1119. /*         DP_NOK - prm-data not OK                                          */
  1120. /*---------------------------------------------------------------------------*/
  1121. #if( ISR_ENABLE_VPC3_INT_NEW_EXT_PRM_DATA == 1 )
  1122. SECTION_DEF_CommuCode UBYTE user_chk_new_ext_prm_data(UBYTE dev_num, VPC3_STRUC_PRM_BLOCK_PTR prmblock_ptr, UBYTE len )
  1123. {
  1124. UBYTE ret_value;
  1126. ret_value = DP_OK;
  1127. len = len;
  1129. // TRACE("user_chk_new_ext_prm_data len:%d cmd:%d slot:%d index:%d ",
  1130. // prmblock_ptr->len&0xff,
  1131. // prmblock_ptr->command&0xff,
  1132. // prmblock_ptr->slot_nr&0xff,
  1133. // prmblock_ptr->index&0xff
  1134. // );
  1135. // 
  1136. //  if(    (prmblock_ptr->command == PBC_USER_PRM_DATA )
  1137. //  && (prmblock_ptr->len     == 0x0C )
  1138. //  && (prmblock_ptr->slot_nr == 0x00 )
  1139. //  && (prmblock_ptr->index   == 0x00 )
  1140. //  )
  1141. //  {
  1142. //  //copy counter parameter data
  1143. //  memcpy( &sSystem[dev_num].prm, &prmblock_ptr->user_data+1, 7 );
  1144. // 
  1145. //  //check parameter of counter module
  1146. //         if(    (sSystem[dev_num].prm.alarm     &  0xFC ) //check alarm
  1147. //             || (sSystem[dev_num].prm.mode      >  0x01 ) //check counter mode
  1148. //             || ( sSystem[dev_num].prm.time_base >  0x05 ) //check counter timebase
  1149. //           )
  1150. //         {
  1151. //          //error
  1152. //          ret_value = DP_PRM_ENTRY_ERROR;
  1153. //         }//if(    (counter.prm.len != 9 )  ... 
  1154. //  }
  1155. //  else
  1156. //  {
  1157. //  ret_value = DP_PRM_BLOCK_ERROR;
  1158. //  }
  1160. return ret_value;
  1161. }
  1162. #endif
  1164. /*---------------------------------------------------------------------------*/
  1165. /* function: user_isr_new_cfg_data   */
  1166. /*                                          */
  1167. /* todo  : check cfg data                                             */
  1168. /*                                          */
  1169. /* return: VPC3_CFG_OK      0  */
  1170. /* VPC3_CFG_FAULT   1  */
  1171. /* VPC3_CFG_UPDATE  2                  */
  1172. /*---------------------------------------------------------------------------*/
  1173. #if( ISR_ENABLE_VPC3_INT_NEW_CFG_DATA == 1 )
  1174. SECTION_DEF_CommuCode UBYTE user_chk_new_cfg_data(UBYTE mdev_num)
  1175. {
  1176. VPC3_UNSIGNED8_PTR  cfg_ptr;   // pointer check config buffer
  1177. UBYTE               ret_value = VPC3_CFG_OK;
  1178. UBYTE               cfg_len;
  1179. UBYTE               i;
  1180. UBYTE               bBU_DO_ModuleExist;
  1181.   UBYTE               bBU_DI_ModuleExist;
  1182. UBYTE               dev_num = mdev_num;
  1183. UBYTE               real_cfg_len;
  1185.     cfg_ptr  = VPC3_GET_CFG_BUF_PTR(dev_num);
  1186.     cfg_len = VPC3_GET_CFG_LEN(dev_num)&0xff;
  1187.                
  1188. if(!g_ProfibusRam.bSiemensCompatiable)
  1189. {
  1190. //和公司主控通讯时
  1191. real_cfg_len = user[dev_num].real_cfg.length&0xff; 
  1193. if( (cfg_len) != real_cfg_len )
  1194. {
  1195. ret_value = VPC3_CFG_FAULT;
  1196. }//if( cfg_len != real_cfg_len )
  1197. else
  1198. {
  1199. if( xmemcmp( &user[dev_num].real_cfg.cfg_data[0], cfg_ptr, user[dev_num].real_cfg.length&0xff ) == 0 ) 
  1200. {
  1201. SetHaveSOEModule(1);//默认只使用1条SOE的空间
  1202. ret_value = VPC3_CFG_UPDATE;//更新配置
  1203. }
  1204. else
  1205. {
  1206. SetHaveSOEModule(0);
  1207. ret_value = VPC3_CFG_FAULT;
  1208. }
  1209. }
  1210. }
  1211. else
  1212. {
  1213. //和其他单位主控通讯时
  1214. bBU_DO_ModuleExist = FALSE;
  1215. bBU_DI_ModuleExist = FALSE;
  1216. if(cfg_len % 4)
  1217. {
  1218. //先检查长度是否合理，1个模建配置数据为4个字节
  1219. ret_value = VPC3_CFG_FAULT;
  1220. }
  1221. else
  1222. {
  1223. //解析模件配置信息
  1224. g_ProfibusRam.nModuleCount = cfg_len/4;
  1225. if(g_ProfibusRam.nModuleCount > MaxModule)
  1226. {
  1227. ret_value = VPC3_CFG_FAULT;
  1228. }
  1229. else
  1230. {
  1231. for (i=0; i<g_ProfibusRam.nModuleCount; i++)
  1232. {
  1233. //检查配置配置信息是否合理
  1234. g_ProfibusRam.CfgModules[i].nModuleID = cfg_ptr[3]&0xff; //模件ID号
  1235. if(g_ProfibusRam.CfgModules[i].nModuleID == ID_MODULE_BUDIDO) //判段是否含有基本输入输出模件
  1236. {
  1237. bBU_DO_ModuleExist = TRUE;
  1238. bBU_DI_ModuleExist = TRUE;
  1239. }
  1240. else if(g_ProfibusRam.CfgModules[i].nModuleID == ID_MODULE_SOE)//判断是否含有SOE模件
  1241. SetHaveSOEModule(1);//默认只使用1条SOE的空间
  1244. if((cfg_ptr[0]&0xff) == 0x82) //输出模件
  1245. {
  1246. g_ProfibusRam.CfgModules[i].nModuleInputBytes = 0;
  1247. g_ProfibusRam.CfgModules[i].nModuleOutputBytes = cfg_ptr[1] & 0x3f;
  1248. }
  1249. else if ((cfg_ptr[0]&0xff) == 0x42)//输入模件
  1250. {
  1251. g_ProfibusRam.CfgModules[i].nModuleInputBytes = cfg_ptr[1] & 0x3f;
  1252. g_ProfibusRam.CfgModules[i].nModuleOutputBytes = 0;
  1253. }
  1254. else if((cfg_ptr[0]&0xff) == 0xC1)//输入输出模件，BU及SOE模件均含输入输出
  1255. {
  1256. g_ProfibusRam.CfgModules[i].nModuleInputBytes = cfg_ptr[1] & 0x3f;
  1257. g_ProfibusRam.CfgModules[i].nModuleOutputBytes = cfg_ptr[2] & 0x3f;
  1258. }
  1259. else  
  1260. {
  1261. //其他的不支持
  1262. ret_value = VPC3_CFG_FAULT;
  1263. }
  1265. cfg_ptr += 4;
  1266. }
  1268. //如果基本开入开出模件不存在，认为是配置出错
  1269. if (!bBU_DO_ModuleExist || !bBU_DI_ModuleExist)
  1270. {
  1271. ret_value = VPC3_CFG_FAULT;
  1272. }
  1273. }
  1275. //更新本地配置数据信息
  1276. if (ret_value != VPC3_CFG_FAULT)
  1277. {
  1278. ret_value = VPC3_CFG_UPDATE;
  1279. }
  1280. }
  1281. }
  1283.     if( ret_value == VPC3_CFG_OK || ret_value == VPC3_CFG_UPDATE)
  1284.     {
  1285. g_nCheckCfgCount[dev_num]++; //累计检查配置次数
  1287.         user_alarm(dev_num, USER_TYPE_CFG_OK, 0, (ALARM_STATUS_PDU_PTR) NULL_PTR, FALSE );
  1288.         user[dev_num].event |= VPC3_EV_NEW_CFG_DATA;
  1289.     }
  1290.     /*
  1291.     else
  1292.         {
  1293.             user_alarm(dev_num, USER_TYPE_CFG_NOK, status_diag.user_data[ 0 ], (ALARM_STATUS_PDU_PTR) NULL_PTR, FALSE );
  1294.         }//else of if( ret_value == VPC3_CFG_UPDATE )*/
  1295.     
  1296.     user_alarm_init(dev_num);
  1297. return ret_value;
  1298. }
  1299. #endif
  1301. /*---------------------------------------------------------------------------*/
  1302. /* function: user_isr_go_leave_data_ex                                       */
  1303. /*---------------------------------------------------------------------------*/
  1304. #if( ISR_ENABLE_VPC3_INT_GO_LEAVE_DATA_EX == 1 )
  1305. SECTION_DEF_CommuCode void user_isr_go_leave_data_ex(UBYTE dev_num)
  1306. {
  1307. if( VPC3_GET_DP_STATE(dev_num) != DATA_EX )
  1308.     {
  1309.         user[dev_num].state = USER_STATE_CLEAR;
  1310.     user[dev_num].application_ready = FALSE;
  1311.     }
  1313. // TRACE("user_isr_go_leave_data_ex %d", dev_num);
  1314. }
  1315. #endif
  1317. /*---------------------------------------------------------------------------*/
  1318. /* function: user_isr_dx_out                                                 */
  1319. /*---------------------------------------------------------------------------*/
  1320. #if( ISR_ENABLE_VPC3_INT_DX_OUT == 1 )
  1321. SECTION_DEF_CommuCode void user_isr_dx_out(UBYTE dev_num)
  1322. {
  1323. user[dev_num].event |= VPC3_EV_DX_OUT;
  1324. }
  1325. #endif
  1327. /*---------------------------------------------------------------------------*/
  1328. /* function: user_isr_diag_buf_changed                                       */
  1329. /*---------------------------------------------------------------------------*/
  1330. #if( ISR_ENABLE_VPC3_INT_DIAG_BUF_CHANGED == 1 )
  1331. SECTION_DEF_CommuCode void user_isr_diag_buf_changed(UBYTE dev_num)
  1332. {
  1333.     // diagnosis buffer has been changed
  1334.     user[dev_num].user_diag_active = FALSE;
  1335.     // Fetch new diagnosis buffer
  1336.     dp_sys[dev_num].diag_buf_ptr.byte_ptr = vpc3_get_diagbufptr(dev_num);
  1337. }
  1338. #endif
  1340. /*---------------------------------------------------------------------------*/
  1341. /* function: user_isr_new_wd_timeout                                         */
  1342. /*---------------------------------------------------------------------------*/
  1343. #if( ISR_ENABLE_VPC3_INT_WD_DP_TIMEOUT == 1 )
  1344. SECTION_DEF_CommuCode void user_isr_new_wd_dp_timeout(UBYTE dev_num)
  1345. {
  1346. reset_diagnostic_buffer(dev_num);
  1347. }
  1348. #endif
  1350. /*---------------------------------------------------------------------------*/
  1351. /* function: user_isr_mac_reset                                              */
  1352. /*---------------------------------------------------------------------------*/
  1353. #if( ISR_ENABLE_VPC3_INT_MAC_RESET == 1 )
  1354. #define CS_SET_TIME             0x01
  1355. #define CS_Clock_Sync_Violation 0X02 
  1357. SECTION_DEF_CommuCode void user_isr_mac_reset(UBYTE dev_num)
  1358. {
  1359. #ifdef DP_TIMESTAMP
  1361. TDateTime fullDt;
  1362. TClockSync* pCS = &p_Vpc3[dev_num]->cs;
  1363. uint64  ullVal;
  1364. uint32 nRcvDelay;//接收延时
  1365. uint32 nTotalSec;
  1366. uint32 nTotalMs;
  1368. user[dev_num].event |= VPC3_EV_MAC_RESET;
  1370. //用于时钟同步功能
  1371.     if (p_Vpc3[dev_num]->mode_reg0_L & 0x80)//启用了时钟同步
  1372.     {
  1373. if (g_ProfibusRam.bClockSyncEnabled)
  1374. {
  1375. //判断时钟状态
  1376. if (p_Vpc3[dev_num]->cs.clock.status &  CS_SET_TIME)
  1377. {
  1378. nTotalSec = MAKEDWORD(MAKEWORD(pCS->clock.cv_time_event[3],pCS->clock.cv_time_event[2]),MAKEWORD(pCS->clock.cv_time_event[1],pCS->clock.cv_time_event[0]));
  1379. ullVal = MAKEDWORD(MAKEWORD(pCS->clock.cv_time_event[3+4],pCS->clock.cv_time_event[2+4]),MAKEWORD(pCS->clock.cv_time_event[1+4],pCS->clock.cv_time_event[0+4])) ;
  1380. ullVal *= 1000000;
  1381. nRcvDelay = MAKEDWORD(MAKEWORD(pCS->clock.rd_time[3],pCS->clock.rd_time[2]),MAKEWORD(pCS->clock.rd_time[1],pCS->clock.rd_time[0]));
  1382. nTotalMs = ( (ullVal >> 32) + nRcvDelay) / 1000;
  1383. if(nTotalMs > 1000)
  1384. {
  1385. nTotalSec+=nTotalMs/1000;
  1386. nTotalMs%=1000;
  1387. }
  1389. //将Profibus时间戳格式转换成全时间格式
  1390. fullDt = _TimeFromSeconds(nTotalSec);
  1391. fullDt.ms = nTotalMs;
  1393. //校正系统时钟 
  1394. fullDt.y %= 100; //2000年开始范围 <= 99
  1395. SetDeviceSystemTime(&fullDt);
  1396. }
  1397. else if(p_Vpc3[dev_num]->cs.clock.status &  CS_Clock_Sync_Violation)
  1398. {
  1399. // TRACE("Clock_Sync_Violation");
  1400. }
  1401. }
  1402.     }
  1403. else
  1404. {
  1405. // TRACE("user_isr_mac_reset");
  1406. }
  1407. #endif
  1408. }
  1409. #endif
  1411. /*---------------------------------------------------------------------------*/
  1412. /* function: user_isr_baudrate_detect                                        */
  1413. /*---------------------------------------------------------------------------*/
  1414. #if( ISR_ENABLE_VPC3_INT_BAUDRATE_DETECT == 1 )
  1415. SECTION_DEF_CommuCode void user_isr_baudrate_detect(UBYTE dev_num)
  1416. {
  1417. //not used in our application
  1418. }
  1419. #endif
  1421. /*---------------------------------------------------------------------------*/
  1422. /* function: user_isr_new_gc_command                                         */
  1423. /*---------------------------------------------------------------------------*/
  1424. #if( ISR_ENABLE_VPC3_INT_NEW_GC_COMMAND == 1 )
  1425. SECTION_DEF_CommuCode void user_isr_new_gc_command(UBYTE dev_num)
  1426. {
  1427. //not used in our application
  1428. }
  1429. #endif
  1431. /*---------------------------------------------------------------------------*/
  1432. /* function: user_isr_new_ssa_data                                           */
  1433. /*---------------------------------------------------------------------------*/
  1434. #if( ISR_ENABLE_VPC3_INT_NEW_SSA_DATA == 1 )
  1435. SECTION_DEF_CommuCode void user_isr_new_ssa_data(UBYTE dev_num)
  1436. {
  1437. //not used in our application
  1439. VPC3_STRUC_SSA_BLOCK_PTR ssa_ptr;
  1441. ssa_ptr = (VPC3_STRUC_SSA_BLOCK_PTR) VPC3_GET_SSA_BUF_PTR(dev_num);
  1443. //一般不使用该功能
  1444. SetSlaveAddressReq(ssa_ptr->address);
  1445. }
  1446. #endif
  1448. /*---------------------------------------------------------------------------*/
  1449. /* function: user_isr_user_timer_clock (10ms)                                */
  1450. /*---------------------------------------------------------------------------*/
  1451. #if( ISR_ENABLE_VPC3_INT_USER_TIMER_CLOCK == 1 )
  1452. SECTION_DEF_CommuCode void user_isr_user_timer_clock(UBYTE dev_num)
  1453. {
  1454. //not used in our application
  1455. }
  1456. #endif
  1458. #ifdef DP_SUBSCRIBER
  1459. /*---------------------------------------------------------------------------*/
  1460. /* function: user_isr_dxb_out                                                */
  1461. /*---------------------------------------------------------------------------*/
  1462. #if( ISR_ENABLE_VPC3_INT_DXB_OUT == 1 )
  1463. SECTION_DEF_CommuCode void user_isr_dxb_out(UBYTE dev_num)
  1464. {
  1465. user[dev_num].event |= VPC3_EV_DXB_OUT;
  1466. }
  1467. #endif
  1469. /*---------------------------------------------------------------------------*/
  1470. /* function: user_isr_dxb_link_error                                         */
  1471. /*---------------------------------------------------------------------------*/
  1472. #if( ISR_ENABLE_VPC3_INT_DXB_LINK_ERROR == 1 )
  1473. SECTION_DEF_CommuCode void user_isr_dxb_link_error(UBYTE dev_num)
  1474. {
  1475. user[dev_num].event |= VPC3_EV_DXB_LINK_ERROR;
  1476. }
  1477. #endif
  1479. #endif//#ifdef DP_SUBSCRIBER
  1481. #ifdef DP_ALARM
  1482. /*--------------------------------------------------------------------------*/
  1483. /* user_alarm_state_info (UBYTE dev_num,called by DPV1)                                   */
  1484. /*--------------------------------------------------------------------------*/
  1485. SECTION_DEF_CommuCode void user_alarm_state_info(UBYTE dev_num, UBYTE alarm_type_bit_field, UBYTE sequence_depth )
  1486. {
  1487. UBYTE i;
  1489.     sequence_depth = sequence_depth;
  1491.     if( alarm_type_bit_field == ALARM_TYPE_NONE_VALUE )
  1492.     {
  1493.         //alarmstatemachine stopped, remove pending alarms
  1494.         for( i = 0; i <= ALARM_MAX_FIFO; i++ )
  1495.         {
  1496.             if( user[dev_num].al.buffer_used[i] == TRUE )
  1497.             {
  1498.                 user[dev_num].al.buffer_used[i] = FALSE;
  1499.             }//if( user[dev_num].al.buffer_used[i] == TRUE )
  1500.         }//for( i = 0; i <= ALARM_MAX_FIFO; i++ )
  1502.         clear_alarm(dev_num, ALARM_TYPE_ALL_VALUE, SEQUENCE_NUMBER_ALL );
  1503.         user[dev_num].al.state = USER_AL_STATE_CLOSED;
  1504.     }//if( alarm_type_bit_field == 0 )
  1505.     else
  1506.     {
  1507.      //enable setted alarms
  1508.         user[dev_num].al.state = USER_AL_STATE_OPEN;
  1509.     }
  1510. }
  1512. /*--------------------------------------------------------------------------*/
  1513. /* user_alarm_ack_req (UBYTE dev_num,called by DPV1)                                      */
  1514. /*--------------------------------------------------------------------------*/
  1515. SECTION_DEF_CommuCode void user_alarm_ack_req(UBYTE dev_num, ALARM_STATUS_PDU_PTR alarm_ptr )//SOE ACK---DPV1
  1516. {
  1517.     logMsg("receive user_alarm_ack_req!n",0,0,0,0,0,0);
  1518.     // alarm_ack from master received
  1519.     // todo: do your alarm-acknowledge handling here
  1520. user_free_alarm_buffer(dev_num, alarm_ptr );
  1522. AlarmACK(dev_num);//报警确认
  1524. reset_diagnostic_buffer(dev_num);
  1525. }
  1526. #endif // #ifdef DP_ALARM
  1529. #ifdef DP_MSAC_C2
  1530. /*--------------------------------------------------------------------------*/
  1531. /* msac_c2_initiate_req (UBYTE dev_num,called by DPV1)                                    */
  1532. /*--------------------------------------------------------------------------*/
  1533. SECTION_DEF_CommuCode DPV1_RET_VAL user_c2_initiate_req(UBYTE dev_num, UBYTE sap, DPV1_PTR pdu )
  1534. {
  1535. MSAC_C2_INITIATE_SUB_PARAM PTR_ATTR * d_addr_ptr;
  1536. DPV1_RET_VAL ret_value;
  1538.     sap = sap;  //avoid warning
  1540. #ifdef DPV1_IM_SUPP
  1541. user[dev_num].awImIndex[ (sap & 0x0F ) ] = 0x0000;
  1542. #endif//#ifdef DPV1_IM_SUPP
  1545. #ifdef _KEIL_C51
  1546.     d_addr_ptr=(MSAC_C2_INITIATE_SUB_PARAM PTR_ATTR * ) &(pdu->initiate_req.addr_data + BFWORD2BYTE(pdu->initiate_req.s_len)); //C51
  1547. #else
  1548.     d_addr_ptr=(MSAC_C2_INITIATE_SUB_PARAM PTR_ATTR* )(pdu->initiate_req.addr_data + BFWORD2BYTE(pdu->initiate_req.s_len)); //166
  1549. #endif //#ifdef _KEIL_C51
  1551.     if( BFWORD2BYTE(d_addr_ptr->api) == 0 )
  1552.     {
  1553.         // in this example only API 0 is supported */
  1554.         if( msac_c2_initiate_req_to_res(dev_num,pdu) == DPV1_OK)
  1555.         {
  1556. //如果界面允许可以跟踪子站所接收的连接情况
  1557. EDD_C2_InitiateReq(dev_num);
  1559.             // Initiate-Request-PDU has been changed to Initiate-Response-PDU */
  1560.             ret_value = DPV1_OK;
  1561.         }
  1562.         else
  1563.         {
  1564.             // D-Typ is no endpoint of connection 
  1565.             // user must handle Initiate-PDU (no change by MSAC_C2)
  1566.             // in this example slave must always be endpoint
  1567.             // create negative response 
  1568.             pdu->neg.err_code1 = DPV1_ERRCL_APPLICATION | DPV1_ERRCL_APP_NOTSUPP;
  1569.             pdu->neg.err_code2 = 0x00;
  1570.             ret_value = DPV1_NOK;
  1571.         }
  1572.     }
  1573.     else
  1574.     {
  1575.         /* create ABORT-PDU */
  1576.         pdu->abort.subnet = MSAC_C2_SUBNET_NO;
  1577.         pdu->abort.instance_reason = MSAC_C2_INSTANCE_MSAC_C2 | MSAC_C2_ABT_IA;
  1578.         ret_value = DPV1_ABORT;
  1579.     }
  1580.     return ret_value;
  1581. }//DPV1_RET_VAL user_c2_initiate_req(UBYTE dev_num, UBYTE sap, DPV1_PTR pdu )
  1584. /*--------------------------------------------------------------------------*/
  1585. /* user_c2_data_transport_req (UBYTE dev_num,called by DPV1)                              */
  1586. /*--------------------------------------------------------------------------*/
  1587. SECTION_DEF_CommuCode DPV1_RET_VAL user_c2_data_transport_req(UBYTE dev_num, UBYTE sap, DPV1_PTR pdu )
  1588. {
  1589. DPV1_RET_VAL ret_value;
  1590. int nBlackfinLoop;
  1591. //uint16* pBlackfinAddr;
  1592. uint16* pSrcAddr;
  1594.     if( sap == DP_C1_RD_WR_SAP_NR )
  1595.     {
  1596.      pdu->neg.err_code1 = DPV1_ERRCL_ACCESS | DPV1_ERRCL_ACC_INV_PARAM;
  1597.         pdu->neg.err_code2 = 0x00;
  1598.         ret_value = DPV1_NOK;
  1599. }//if( sap == DP_C1_RD_WR_SAP_NR )
  1600. else
  1601. {
  1602. if( BFWORD2BYTE( pdu->transport.length) > (C2_LEN-4) )
  1603. {
  1604. pdu->transport.length = (C2_LEN-4);
  1605. }
  1607.      if( BFWORD2BYTE(pdu->transport.slot_num) == 0x00 )
  1608.      {
  1609.          if( BFWORD2BYTE(pdu->transport.index) == 0x02 )
  1610.          {
  1611.              //memcpy( &user[dev_num].dpv1_rw_buffer[0], &pdu->transport.pdu_data[0], pdu->transport.length );
  1612. pSrcAddr = (uint16*)&pdu->transport.pdu_data[0];
  1614. for (nBlackfinLoop=0; nBlackfinLoop<BFWORD2BYTE(pdu->transport.length); nBlackfinLoop++)
  1615. {
  1616. user[dev_num].dpv1_rw_buffer[nBlackfinLoop] = pSrcAddr[nBlackfinLoop];
  1617. }
  1618.              ret_value = DPV1_OK;
  1619.          }//if( pdu->transport.index == 0x00 )
  1620.          else
  1621.          {
  1622.              pdu->neg.err_code1 = DPV1_ERRCL_ACCESS | DPV1_ERRCL_ACC_INV_INDEX;
  1623.              pdu->neg.err_code2 = 0x00;
  1624.              ret_value = DPV1_NOK;
  1625.          }//else of if( pdu->v.index == 0x00 )
  1626.      }//if( pdu->transport.slot_num == 0x00 )
  1627.      else
  1628.      {
  1629.          pdu->neg.err_code1 = DPV1_ERRCL_ACCESS | DPV1_ERRCL_ACC_INV_SLOT;
  1630.          pdu->neg.err_code2 = 0x00;
  1631.          ret_value = DPV1_NOK;
  1632.      }//else of if( pdu->transport.slot_num == 0x00 )
  1633. }//else of if( sap == DP_C1_RD_WR_SAP_NR )
  1635.     return ret_value;
  1636. }//DPV1_RET_VAL user_c2_data_transport_req(UBYTE dev_num,UBYTE sap, DPV1_PTR pdu)
  1639. /*--------------------------------------------------------------------------*/
  1640. /* dpv1_abort_ind (UBYTE dev_num,called by DPV1)                                          */
  1641. /*--------------------------------------------------------------------------*/
  1642. SECTION_DEF_CommuCode DPV1_RET_VAL user_c2_abort_ind(UBYTE dev_num,UBYTE sap, DPV1_PTR pdu)
  1643. {
  1644.     sap = sap;  //avoid warning
  1645.     pdu = pdu;  //avoid warning
  1647. #ifdef DPV1_IM_SUPP
  1648. user[dev_num].awImIndex[ (sap & 0x0F ) ] = 0x0000;
  1649. #endif//#ifdef DPV1_IM_SUPP
  1651. EDD_C2_AbortInd(dev_num);
  1653.     return DPV1_OK;
  1654. }//DPV1_RET_VAL user_c2_abort_ind(UBYTE dev_num,UBYTE sap, DPV1_PTR pdu)
  1655. #endif //#ifdef DP_MSAC_C2
  1659. #ifdef DP_FDL
  1660. /*--------------------------------------------------------------------------*/
  1661. /* user_dpv1_read_req (called by DPV1)                                      */
  1662. /*--------------------------------------------------------------------------*/
  1663. SECTION_DEF_CommuCode DPV1_RET_VAL user_dpv1_read_req(UBYTE dev_num, UBYTE sap, DPV1_PTR pdu)//dpv1 read complete the task data from user to buffer 
  1664. {
  1665. DPV1_RET_VAL  ret_value;
  1666. UBYTE         max_length=0;
  1667. //int nBlackfinLoop;
  1668. //uint16* pBlackfinAddr;
  1670.    int i;
  1671.    uint8* pDataRet;
  1672.    uint8 nDataLenRet;
  1673.    uint8 nErrCode1, nErrCode2;
  1675.    g_nC1ReadCount[dev_num]++;
  1676.    ret_value = DPV1_OK;
  1678. #ifdef DPV1_IM_SUPP
  1679. psIMCALL ps_ImCall;
  1680. #endif//#ifdef DPV1_IM_SUPP
  1682. #ifdef DPV1_IM_SUPP
  1683. if( BFWORD2BYTE(pdu->read.index) == 255 )
  1684. {
  1685. if( BFWORD2BYTE(pdu->read.slot_num) == 0 )
  1686. {
  1687. //check_extended function number, reserved byte and IM_INDEX
  1688. if( user[dev_num].awImIndex[ ( sap & 0x0F ) ] == IM0_INDEX )
  1689. {
  1690. ps_ImCall = (psIMCALL)&pdu->read.pdu_data[0];
  1691. ps_ImCall->bExtendedFunctionNumber = IM_FN_CALL;  
  1692. ps_ImCall->bReserved = 0x00;
  1693. ps_ImCall->wIndex = BFWORD2LONG(user[dev_num].awImIndex[ ( sap & 0x0F ) ]);
  1694.     //memcpy( &pdu->read.pdu_data[4], &IM_DEFAULT[0], SizeOfIM0 );
  1695.                     pBlackfinAddr = (uint16*)&pdu->read.pdu_data[4];
  1696. for (nBlackfinLoop=0; nBlackfinLoop<SizeOfIM0; nBlackfinLoop++)
  1697. {
  1698. pBlackfinAddr[nBlackfinLoop] = IM_DEFAULT[nBlackfinLoop];
  1699. }
  1701.      if( BFWORD2BYTE(pdu->read.length) > (4 + SizeOfIM0) )
  1702.      {
  1703.     pdu->read.length = 4 + SizeOfIM0;
  1704.      }
  1705. }//if( user.awImIndex[ ( sap & 0x0F ) ] == IM0_INDEX )
  1706. else
  1707. {
  1708.           pdu->neg.err_code1 = DPV1_ERRCL_ACCESS | DPV1_ERRCL_ACC_INV_PARAM;
  1709.           pdu->neg.err_code2 = 0x00;
  1710.           ret_value = DPV1_NOK;
  1711. }//else of if( user.awImIndex[ ( sap & 0x0F ) ] == IM0_INDEX )  
  1712. }//if( pdu->read.slot_num == 0 )
  1713. else
  1714. {
  1715.          pdu->neg.err_code1 = DPV1_ERRCL_ACCESS | DPV1_ERRCL_ACC_INV_SLOT;
  1716.          pdu->neg.err_code2 = 0x00;
  1717.          ret_value = DPV1_NOK;
  1718.          }//else of if( pdu->read.slot_num == 0 )
  1719. }
  1720. #else
  1721. if( BFWORD2BYTE(pdu->read.index) == 255 )
  1722. {
  1723.          pdu->neg.err_code1 = DPV1_ERRCL_ACCESS | DPV1_ERRCL_ACC_INV_INDEX;
  1724.          pdu->neg.err_code2 = 0x00;
  1725.          ret_value = DPV1_NOK;
  1726. }
  1727. #endif//#ifdef DPV1_IM_SUPP
  1729. //应用处理部分
  1730. else if(ret_value == DPV1_OK)
  1731. {
  1732. switch(BFWORD2BYTE( pdu->read.slot_num ))
  1733. {
  1734.             case SlotNum_Read_BhPara:
  1735.             case SlotNum_Read_Energy:
  1736.             case SlotNum_Read_WaveConfig:
  1737.             case SlotNum_Read_WaveData_File_Zone0:
  1738.             case SlotNum_Read_WaveData_File_Zone1:
  1739.             case SlotNum_Read_WaveData_File_Zone2:
  1740.             case SlotNum_Read_WaveData_File_Zone3:
  1741.             case SlotNum_Read_WaveData_Sample_Zone0:
  1742.             case SlotNum_Read_WaveData_Sample_Zone1:
  1743.             case SlotNum_Read_WaveData_Sample_Zone2:
  1744.             case SlotNum_Read_WaveData_Sample_Zone3:
  1745.             case SlotNum_Read_WaveData_Sample_Zone4:
  1746.             case SlotNum_Read_WaveData_Sample_Zone5:
  1747.             case SlotNum_Read_BhPara_Zone0:
  1748.             case SlotNum_Read_BhPara_Zone1:
  1749.             case SlotNum_Read_BhPara_Zone2:
  1750.             case SlotNum_Read_BhPara_Zone3:
  1751.             case SlotNum_Read_BhPara_Zone4:
  1752.             case SlotNum_Read_BhPara_Zone5:
  1753. case SlotNum_Read_DeviceInfo:
  1754. case SlotNum_Read_WaveData_Comtrade_Zone0:
  1755. case SlotNum_Read_WaveData_Comtrade_Zone1:
  1756. case SlotNum_Read_WaveData_Comtrade_Zone2:
  1757. case SlotNum_Read_WaveData_Comtrade_Zone3:
  1758. case SlotNum_Read_WaveData_Comtrade_Zone4:
  1759. case SlotNum_Read_WaveData_Comtrade_Zone5:
  1760. case SlotNum_Read_WaveData_Comtrade_Zone6:
  1761. case SlotNum_Read_WaveData_Comtrade_Zone7:
  1762. case SlotNum_Read_WaveData_Comtrade_Zone8:
  1763. case SlotNum_50:
  1764. case SlotNum_51:
  1765. case SlotNum_52:
  1766. case SlotNum_53:
  1767. case SlotNum_54:
  1768. case SlotNum_55:
  1769. {
  1770. ret_value = DPV1_ReadReq(dev_num, pdu->read.slot_num&0xff, pdu->read.index&0xff, pdu->read.length&0xff, &pDataRet, &nDataLenRet,
  1771. &nErrCode1, &nErrCode2);
  1773. if(ret_value == DPV1_OK && pDataRet)
  1774. {
  1775. for(i=0; i<mmin(MAX_DPV1_DU_COUNT, nDataLenRet); i++)
  1776. {
  1777. pdu->read.pdu_data[i] = pDataRet[i];
  1778. }
  1779. max_length = nDataLenRet;
  1781. if( BFWORD2BYTE(pdu->read.length) > max_length )
  1782. {
  1783. pdu->read.length = max_length;
  1784. }
  1785. }
  1786. else
  1787. {
  1788. pdu->neg.err_code1 = nErrCode1;
  1789. pdu->neg.err_code2 = nErrCode2;
  1790. }
  1791. }
  1792. break;
  1793. default:
  1794. {
  1795. pdu->neg.err_code1 = DPV1_ERRCL_ACCESS | DPV1_ERRCL_ACC_INV_SLOT;
  1796. pdu->neg.err_code2 = 0x00;
  1797. ret_value = DPV1_NOK;
  1798. break;
  1799. }
  1800. }
  1802. }
  1804.     return ret_value;
  1805. }//DPV1_RET_VAL user_dpv1_read_req(UBYTE sap, DPV1_PTR pdu)
  1808. /*--------------------------------------------------------------------------*/
  1809. /* user_dpv1_write_req (called by DPV1)                                     */
  1810. /*--------------------------------------------------------------------------*/
  1811. SECTION_DEF_CommuCode DPV1_RET_VAL user_dpv1_write_req(UBYTE dev_num, UBYTE sap, DPV1_PTR pdu)
  1812. {
  1813. DPV1_RET_VAL ret_value;
  1814. //UBYTE        max_length;
  1815. #ifdef DPV1_IM_SUPP
  1816. psIMCALL ps_ImCall;
  1817. #endif//#ifdef DPV1_IM_SUPP
  1819.    int i;
  1820.    uint8 nErrCode1, nErrCode2;
  1821.    SECTION_DEF_CommuData static uint8 WriteBuffer[240];
  1823.    g_nC1WriteCount[dev_num]++;
  1824.    ret_value = DPV1_OK;
  1826. #ifdef DPV1_IM_SUPP
  1827. if( BFWORD2BYTE(pdu->write.index) == 255 )
  1828. {
  1829. if( BFWORD2BYTE(pdu->write.slot_num) == 0 )
  1830. {
  1831. //check_extended function number, reserved byte and IM_INDEX
  1832. ps_ImCall = (psIMCALL)&pdu->write.pdu_data[0];
  1833. if(    ( BFWORD2BYTE(ps_ImCall->bExtendedFunctionNumber) == IM_FN_CALL )
  1834. && ( BFWORD2BYTE(ps_ImCall->bReserved) == 0x00                     )
  1835.   )
  1836. {
  1837. //check IM_INDEX
  1838. if( BFLONG2WORD(ps_ImCall->wIndex) == IM0_INDEX )
  1839. {
  1840. //OK, save IM_INDEX
  1841. user[dev_num].awImIndex[ ( sap & 0x0F ) ] = IM0_INDEX;
  1842. }//if( ps_ImCall->wIndex == IM0_INDEX )
  1843. else
  1844. {
  1845.           pdu->neg.err_code1 = DPV1_ERRCL_ACCESS | DPV1_ERRCL_APP_NOTSUPP;
  1846.           pdu->neg.err_code2 = 0x00;
  1847.           ret_value = DPV1_NOK;
  1848. }//else of if( ps_ImCall->wIndex == IM0_INDEX )
  1849. }//if(    ( ps_ImCall->bExtendedFunctionNumber == IM_FN_CALL ) ...
  1850. else
  1851. {
  1852.           pdu->neg.err_code1 = DPV1_ERRCL_ACCESS | DPV1_ERRCL_ACC_INV_PARAM;
  1853.           pdu->neg.err_code2 = 0x00;
  1854.           ret_value = DPV1_NOK;
  1855. }//else of if(    ( ps_ImCall->bExtendedFunctionNumber == IM_FN_CALL ) ...   
  1856. }//if( pdu->write.slot_num == 0 )
  1857. else
  1858. {
  1859.          pdu->neg.err_code1 = DPV1_ERRCL_ACCESS | DPV1_ERRCL_ACC_INV_SLOT;
  1860.          pdu->neg.err_code2 = 0x00;
  1861.          ret_value = DPV1_NOK;
  1862.          }//if( pdu->write.slot_num == 0 )
  1863. }
  1864. #else
  1865. if( BFWORD2BYTE(pdu->write.index) == 255 )
  1866. {
  1867.          pdu->neg.err_code1 = DPV1_ERRCL_ACCESS | DPV1_ERRCL_ACC_INV_INDEX;
  1868.          pdu->neg.err_code2 = 0x00;
  1869.          ret_value = DPV1_NOK;
  1870. }
  1871. #endif//#ifdef DPV1_IM_SUPP
  1872.         else 
  1873. {
  1874. switch( BFWORD2BYTE(pdu->write.slot_num ))
  1875. {
  1876.             case SlotNum_Write_BhPara:
  1877.             case SlotNum_Write_StartWave:
  1878.             case SlotNum_Write_ModifyTime:
  1879.             case SlotNum_Write_CtrlSelect:
  1880.             case SlotNum_Write_CtrlExecute:
  1881. case SlotNum_Write_CtrlCancel:
  1882.             case SlotNum_Write_ResetSignal:
  1883.             case SlotNum_Write_BhPara_Zone0:
  1884. case SlotNum_Write_BhPara_Zone1:
  1885.             case SlotNum_Write_BhPara_Zone2:
  1886.             case SlotNum_Write_BhPara_Zone3:
  1887.             case SlotNum_Write_BhPara_Zone4:
  1888. case SlotNum_Write_BhPara_Zone5:
  1889. case SlotNum_50:
  1890. case SlotNum_51:
  1891. case SlotNum_52:
  1892. case SlotNum_53:
  1893. case SlotNum_54:
  1894. case SlotNum_55:
  1895. {
  1896. //转换成uint8型数据
  1897. for(i=0; i<BFWORD2BYTE(pdu->write.length); i++)
  1898. {
  1899. WriteBuffer[i] = pdu->write.pdu_data[i];
  1900. }
  1902. ret_value = DPV1_WriteReq(dev_num, pdu->write.slot_num&0xff, pdu->write.index&0xff, pdu->write.length&0xff, WriteBuffer, &nErrCode1, &nErrCode2);
  1904. if(ret_value == DPV1_NOK)
  1905. {
  1906. pdu->neg.err_code1 = nErrCode1;
  1907. pdu->neg.err_code2 = nErrCode2;
  1908. }
  1909. }
  1910. break;
  1912. default:
  1913. {
  1914. pdu->neg.err_code1 = DPV1_ERRCL_ACCESS | DPV1_ERRCL_ACC_INV_SLOT;
  1915. pdu->neg.err_code2 = 0x00;
  1916. ret_value = DPV1_NOK;
  1917. break;
  1918. }
  1919. }
  1920. }
  1922. return ret_value;
  1923. }//DPV1_RET_VAL user_dpv1_write_req(UBYTE sap, DPV1_PTR pdu)
  1925. #endif // #ifdef DP_FDL