dp_user.c

PROFIBUS SLAVE PROGRAMS PRO FIBUS SLAVE PROGRAMS

        #ifdef RS232_SERIO
            if(rec_counter > 0)
            {
                print_serial_inputs();
            }
        #endif//#ifdef RS232_SERIO

        TOGGLE_LED_RED__;
        TOGGLE_LED_YLW__;

        delay();
    }//while(1)
}//void fatal_error( DP_ERROR_FILE file, UWORD line, VPC3_ERRCB_PTR errcb_ptr )

/*---------------------------------------------------------------------------*/
/* function: user_isr_new_prm_data                                           */
/*                                                                           */
/* todo  : check the prm-data                                                */
/* return: DP_OK  - prm-data OK                                              */
/*         DP_NOK - prm-data not OK                                          */
/*---------------------------------------------------------------------------*/
#if( ISR_ENABLE_VPC3_INT_NEW_PRM_DATA == 1 )
UBYTE user_chk_new_prm_data( VPC3_UNSIGNED8_PTR prm_ptr, UBYTE len )
{
VPC3_STRUC_PRM_PTR          prm_data;
UBYTE                       ret_value;

    ret_value = DP_OK;

    if( len == PRM_LEN_DPV1 )
    {
        prm_data = (VPC3_STRUC_PRM_PTR)prm_ptr;

        //check DPV1 Status
        if(    ( prm_data->dpv1_status_1 != 0x00 )
            || ( prm_data->dpv1_status_2 != 0x00 )
            || ( prm_data->dpv1_status_3 != 0x00 )
          )
        {
            ret_value = DP_PRM_DPV1_STATUS;
        }//if(    (( prm_data->dpv1_status_2 & 0x02 ) != 0x00 ) ...
    }//if( len >= PRM_LEN_DPV1 )
    else
    {
        ret_value = DP_PRM_LEN_ERROR;
    }//else of if( len >= PRM_LEN_DPV1 )

    if( ( VPC3_GET_DP_STATE() == DATA_EX ) && ( ret_value == DP_OK ) )
    {
        //don't send diagnostic here
    }//if( ( VPC3_GET_DP_STATE() == DATA_EX ) && ( ret_value == DP_OK ) )
    else
    {
        user_alarm( USER_TYPE_PRM_OK, FALSE );
    }//else of if( ( VPC3_GET_DP_STATE() == DATA_EX ) && ( ret_value == DP_OK ) )

    return ret_value;
}//UBYTE user_chk_new_prm_data( VPC3_UNSIGNED8_PTR prm_ptr, UBYTE len )
#endif//#if( ISR_ENABLE_VPC3_INT_NEW_PRM_DATA == 1 )

/*---------------------------------------------------------------------------*/
/* function: UsrFindCfgByte                                                  */
/*---------------------------------------------------------------------------*/
UBYTE UsrFindCfgByte( UBYTE bCfg )
{
UBYTE bRetValue;
UBYTE i;

    bRetValue = FALSE;

    for( i = 0; i < AllCfgDataLength; i++ )
    {
        if( bCfg == AllCfgBytes[ i ] )
        {
            bRetValue = TRUE;
            break;
        }//if( bCfg == AllCfgBytes[ i ] )
    }//for( i = 0; i < AllCfgDataLength; i++ )

    return bRetValue;
}//UBYTE UsrFindCfgByte( UBYTE bCfg )

/*---------------------------------------------------------------------------*/
/* function: user_isr_new_cfg_data                                           */
/*                                                                           */
/* todo  : check cfg data                                                    */
/*                                                                           */
/* return:  VPC3_CFG_OK      0                                               */
/*          VPC3_CFG_FAULT   1                                               */
/*          VPC3_CFG_UPDATE  2                                               */
/*---------------------------------------------------------------------------*/
#if( ISR_ENABLE_VPC3_INT_NEW_CFG_DATA == 1 )
UBYTE user_chk_new_cfg_data( void )
{
VPC3_UNSIGNED8_PTR  cfg_ptr;        // pointer check config buffer
UBYTE               cfg_len;
UBYTE               ret_value;
UBYTE               i;

    ret_value = VPC3_CFG_UPDATE;
    cfg_len = VPC3_GET_CFG_LEN();

    //max module in gsd-file: 20
    if( ( cfg_len > 0 ) && ( cfg_len <= 20 ) )
    {
        cfg_ptr = VPC3_GET_CFG_BUF_PTR();

        for( i = 0; i < cfg_len; i++ )
        {
            if( UsrFindCfgByte( *cfg_ptr ) == FALSE )
            {
                //cfg byte not defined
                ret_value = VPC3_CFG_FAULT;
                break;
            }//if( UsrFindCfgByte(i) == FALSE )

            cfg_ptr++;
        }//for( i = 0; i < cfg_len; i++ )
    }//if( ( cfg_len > 0 ) && ( cfg_len <= 20 ) )
    else
    {
        ret_value = VPC3_CFG_FAULT;
    }//else of if( ( cfg_len > 0 ) && ( cfg_len <= 20 ) )

    if( ret_value == VPC3_CFG_UPDATE )
    {
        user_alarm( USER_TYPE_CFG_OK, FALSE );
        user.event |= VPC3_EV_NEW_CFG_DATA;
    }//if( ret_value == VPC3_CFG_UPDATE )
    return ret_value;
}//UBYTE user_chk_new_cfg_data( void )
#endif//#if( ISR_ENABLE_VPC3_INT_NEW_CFG_DATA == 1 )

/*---------------------------------------------------------------------------*/
/* function: user_isr_go_leave_data_ex                                       */
/*---------------------------------------------------------------------------*/
#if( ISR_ENABLE_VPC3_INT_GO_LEAVE_DATA_EX == 1 )
void user_isr_go_leave_data_ex( void )
{
    if( VPC3_GET_DP_STATE() != DATA_EX )
    {
        user.state = USER_STATE_CLEAR;
        user.application_ready = FALSE;
    }//if( VPC3_GET_DP_STATE() != DATA_EX )
}//void user_isr_go_leave_data_ex( void )
#endif//#if( ISR_ENABLE_VPC3_INT_GO_LEAVE_DATA_EX == 1 )

/*---------------------------------------------------------------------------*/
/* function: user_isr_dx_out                                                 */
/*---------------------------------------------------------------------------*/
#if( ISR_ENABLE_VPC3_INT_DX_OUT == 1 )
void user_isr_dx_out( void )
{
    user.event |= VPC3_EV_DX_OUT;
}//void user_isr_dx_out( void )
#endif//#if( ISR_ENABLE_VPC3_INT_DX_OUT == 1 )

/*---------------------------------------------------------------------------*/
/* function: user_isr_diag_buf_changed                                       */
/*---------------------------------------------------------------------------*/
#if( ISR_ENABLE_VPC3_INT_DIAG_BUF_CHANGED == 1 )
void user_isr_diag_buf_changed( void )
{
    // diagnosis buffer has been changed
    user.user_diag_active = FALSE;
    // Fetch new diagnosis buffer
    dp_sys.diag_buf_ptr.byte_ptr = vpc3_get_diagbufptr();
}//void user_isr_diag_buf_changed( void )
#endif//#if( ISR_ENABLE_VPC3_INT_DIAG_BUF_CHANGED == 1 )

/*---------------------------------------------------------------------------*/
/* function: user_isr_new_wd_timeout                                         */
/*---------------------------------------------------------------------------*/
#if( ISR_ENABLE_VPC3_INT_WD_DP_TIMEOUT == 1 )
void user_isr_new_wd_dp_timeout( void )
{
    reset_diagnostic_buffer();
}//void user_isr_new_wd_dp_timeout( void )
#endif//#if( ISR_ENABLE_VPC3_INT_WD_DP_TIMEOUT == 1 )

/*---------------------------------------------------------------------------*/
/* function: user_isr_new_ext_prm_data                                       */
/*                                                                           */
/* todo  : check the prm-data                                                */
/* return: DP_OK  - prm-data OK                                              */
/*         DP_NOK - prm-data not OK                                          */
/*---------------------------------------------------------------------------*/
#if( ISR_ENABLE_VPC3_INT_NEW_EXT_PRM_DATA == 1 )
UBYTE user_chk_new_ext_prm_data( VPC3_STRUC_PRM_BLOCK_PTR prmblock_ptr, UBYTE len )
{
    //not used
    return DP_OK;
}//UBYTE user_chk_new_ext_prm_data( VPC3_STRUC_PRM_BLOCK_PTR prmblock_ptr, UBYTE len )
#endif//#if( ISR_ENABLE_VPC3_INT_NEW_EXT_PRM_DATA == 1 )

/*---------------------------------------------------------------------------*/
/* function: user_isr_mac_reset                                              */
/*---------------------------------------------------------------------------*/
#if( ISR_ENABLE_VPC3_INT_MAC_RESET == 1 )
void user_isr_mac_reset( void )
{
    //not used in our application
}//void user_isr_mac_reset( void )
#endif//#if( ISR_ENABLE_VPC3_INT_MAC_RESET == 1 )

/*---------------------------------------------------------------------------*/
/* function: user_isr_baudrate_detect                                        */
/*---------------------------------------------------------------------------*/
#if( ISR_ENABLE_VPC3_INT_BAUDRATE_DETECT == 1 )
void user_isr_baudrate_detect( void )
{
    //not used in our application
}//void user_isr_baudrate_detect( void )
#endif//#if( ISR_ENABLE_VPC3_INT_BAUDRATE_DETECT == 1 )

/*---------------------------------------------------------------------------*/
/* function: user_isr_new_gc_command                                         */
/*---------------------------------------------------------------------------*/
#if( ISR_ENABLE_VPC3_INT_NEW_GC_COMMAND == 1 )
void user_isr_new_gc_command( void )
{
    //not used in our application
}//void user_isr_new_gc_command( void )
#endif//#if( ISR_ENABLE_VPC3_INT_NEW_GC_COMMAND == 1 )

/*---------------------------------------------------------------------------*/
/* function: user_isr_new_ssa_data                                           */
/*---------------------------------------------------------------------------*/
#if( ISR_ENABLE_VPC3_INT_NEW_SSA_DATA == 1 )
void user_isr_new_ssa_data( void )
{
    //not used in our application
}void user_isr_new_ssa_data( void )
#endif//#if( ISR_ENABLE_VPC3_INT_NEW_SSA_DATA == 1 )

/*---------------------------------------------------------------------------*/
/* function: user_isr_user_timer_clock (10ms)                                */
/*---------------------------------------------------------------------------*/
#if( ISR_ENABLE_VPC3_INT_USER_TIMER_CLOCK == 1 )
void user_isr_user_timer_clock( void )
{
    //not used
}//void user_isr_user_timer_clock( void )
#endif//#if( ISR_ENABLE_VPC3_INT_USER_TIMER_CLOCK == 1 )


/*****************************************************************************/
/*  Copyright (C) profichip GmbH 2005. Confidential.                         */
/*****************************************************************************/