dp_user.c

PROFIBUS SLAVE PROGRAMS PRO FIBUS SLAVE PROGRAMS

                {
                    //diagnostic alarm
                    if( (alarm_ptr->spec & SPEC_MASK) == SPEC_APPEARS )
                    {
                        //only an example
                        //add here for the appearing diagnostic alarm the channel related diagnostic
                        ext_diag = EXT_DIAG_SET;
                        if( alarm_ptr->slot == 0x05 )
                        {
                            //module 5
                            memcpy( tmp_diag.byte_ptr+len_diag, (UBYTE *)&chn_diag_5[0], 3 );
                            len_diag += 3;
                        }
                        else
                        {
                            //module 6
                            memcpy( tmp_diag.byte_ptr+len_diag, (UBYTE *)&chn_diag_6[0], 3 );
                            len_diag += 3;
                        }
                    }

                    memcpy( tmp_diag.byte_ptr+len_diag, (UBYTE *)&alarm_ptr->header, szAlarmHeader );
                    len_diag += szAlarmHeader;
                    memcpy( tmp_diag.byte_ptr+len_diag, alarm_ptr->user_data_ptr, szUsrDiagnosticAlarmData );
                    len_diag += szUsrDiagnosticAlarmData;
                }
                break;
            }

            case USER_TYPE_APPL_RDY:
            case USER_TYPE_PRM_NOK:
            case USER_TYPE_PRM_OK:
            default:
            {
                ext_diag = 0x00;
                len_diag = 0x00;
                break;
            }//default:
        }//switch(user[vpc3_channel].diag_byte)

        user.user_diag_active = TRUE;

        error = set_diagnosis( tmp_diag, len_diag, ext_diag, check_diag_flag  );

        if( error == DP_OK )
        {
            user.old_diag = diag;
            if( alarm_type >= USER_TYPE_PRM_OK )
            {
                user.user_diag_active = FALSE;
            }//if( alarm_type >= USER_TYPE_PRM_OK )
            ret_value = DP_OK;
        }//if( error == DP_OK )
        else
        {
            user.user_diag_active = FALSE;

            #ifdef RS232_SERIO
                print_string("DIAG_DP_Error: ");
                print_hexbyte(error);
                print_hexbyte(alarm_type);
            #endif//#ifdef RS232_SERIO
            ret_value = error;
        }//else of if( error == DP_OK )
    }//if(     ( diag  != user.old_diag         ) ...

    return ret_value;
}//UBYTE user_alarm( UBYTE diag_event, UBYTE crc_byte, ALARM_STATUS_PDU_PTR alarm_ptr )

/*--------------------------------------------------------------------------*/
/* function: user_demo_diagnostic                                           */
/*--------------------------------------------------------------------------*/
UBYTE user_demo_diagnostic( UBYTE diag_nr, UBYTE module_nr )
{
ROMCONST__ UBYTE diagnostic_alarm_appears[5]    = { 0x01,0x07,0x0F,0x67,0x33 };
ROMCONST__ UBYTE diagnostic_alarm_disappears[5] = { 0x01,0x00,0x0F,0x00,0x00 };

static UBYTE diagnostic_alarm_seq_nr;

ALARM_STATUS_PDU_PTR p_alarm;
UBYTE ret_value;
UBYTE callback;

    ret_value = TRUE;

    p_alarm = user_alarm_alloc();
    if( p_alarm != NULL )
    {
        callback = FALSE;
        switch( diag_nr )
        {
            case 1:
            case 3:
            {
                diagnostic_alarm_seq_nr = (diagnostic_alarm_seq_nr + 1) & (MAX_SEQ_NR - 1);
                p_alarm->header         = szDiagnosticAlarm;
                p_alarm->type           = STATUS_MESSAGE;
                p_alarm->slot           = module_nr;
                p_alarm->spec           = SPEC_APPEARS + (diagnostic_alarm_seq_nr << SPEC_SEQ_START);
                p_alarm->user_data_len  = szUsrDiagnosticAlarmData;
                memcpy( p_alarm->user_data_ptr, &diagnostic_alarm_appears[0], szUsrDiagnosticAlarmData );
                //The alarm state machine calls the function user_alarm again.
                //The user can can add to the alarm e.g. module status or channel related diagnostic.
                callback = TRUE;
                break;
            }

            case 2:
            case 4:
            {
                diagnostic_alarm_seq_nr = (diagnostic_alarm_seq_nr + 1) & (MAX_SEQ_NR - 1);
                p_alarm->header         = szDiagnosticAlarm;
                p_alarm->type           = STATUS_MESSAGE;
                p_alarm->slot           = module_nr;
                p_alarm->spec           = SPEC_DISAPPEARS + (diagnostic_alarm_seq_nr << SPEC_SEQ_START);
                p_alarm->user_data_len  = szUsrDiagnosticAlarmData;
                memcpy( p_alarm->user_data_ptr, &diagnostic_alarm_disappears[0], szUsrDiagnosticAlarmData );
                break;
            }

            default:
            {
                break;
            }
        }//switch( diag_nr )

        user_alarm( USER_TYPE_DPV0, p_alarm->spec, p_alarm, FALSE );
        user_free_alarm_buffer( p_alarm );
    }//if( p_alarm != NULL )

    return ret_value;
}//UBYTE user_demo_diagnostic( UBYTE diag_nr )

/*--------------------------------------------------------------------------*/
/* function: read_input_data                                                */
/*--------------------------------------------------------------------------*/
void read_input_data( void )
{
VPC3_UNSIGNED8_PTR  input_buf_ptr;  // pointer to input buffer

    // write DIN data to VPC3
    if(input_buf_ptr = vpc3_get_dinbufptr ())            // get pointer to DIN data
    {
        //todo:
        //handle here data (slave --> master)

        memcpy( input_buf_ptr, &sSystem.input.di8[0], dp_sys.inp_data_len );

        // the user makes a new Din-Buffer available in the state N
        dp_sys.vpc3_con = VPC3_INPUT_UPDATE();
    }//if(input_buf_ptr = vpc3_get_dinbufptr ())
}//void read_input_data( void )

/*--------------------------------------------------------------------------*/
/* function: application_ready                                              */
/*--------------------------------------------------------------------------*/
void application_ready( void )
{
    //todo
    //make here your own initialization

    //read input data
    read_input_data();
    //reset Diag.Stat
    user_alarm( USER_TYPE_APPL_RDY, 0, (ALARM_STATUS_PDU_PTR) NULL_PTR, FALSE );
    user.application_ready = TRUE;
}//void application_ready( void )

/*---------------------------------------------------------------------------*/
/* function: user_main                                                       */
/*---------------------------------------------------------------------------*/
void user_main( void )
{
VPC3_UNSIGNED8_PTR  output_buf_ptr; // pointer to output buffer
DP_ERROR_CODE       error;
UBYTE               outp_state;     // state of output data
#ifdef EvaBoard_AT89C5132
    UBYTE           bDipSwitch5;
    UBYTE           bOldDipSwitch5;
    UBYTE           bDiagStateModule5;
    UBYTE           bDiagStateModule6;
#endif//#ifdef EvaBoard_AT89C5132

    /*-----------------------------------------------------------------------*/
    /* init user data                                                        */
    /*-----------------------------------------------------------------------*/
    memset( &user, 0, sizeof(user) );

    /* TRUE  deactivates diagnosis handling ! */
    /* FALSE activates   diagnosis handling ! */
    user.user_diag_active  = FALSE;
    user.application_ready = FALSE;
    user.state = USER_STATE_CLEAR;

    /*-----------------------------------------------------------------------*/
    /* init System                                                           */
    /*-----------------------------------------------------------------------*/
    memset( &sSystem, 0, sizeof(STRUC_SYSTEM) );
    sSystem.NrOfModules = MaxModule;

    /*-----------------------------------------------------------------------*/
    /* initialize VPC3                                                       */
    /*-----------------------------------------------------------------------*/

    //todo:
    //insert your real configuration data here
    user.real_cfg.length = (MaxModule*4); // length of configuration data
    memcpy( &user.real_cfg.cfg_data[0], &DefCfg[0], user.real_cfg.length );

    #ifdef EvaBoard_AT89C5132
        error = vpc3_initialization( (*READ_PORT0 & 0x7F), user.real_cfg );     // address of slave; PORT0
    #else
        error = vpc3_initialization( DP_ADDR, user.real_cfg );                  // address of slave
    #endif//#ifdef EvaBoard_AT89C5132

    if( DP_OK == error )
    {
        // set microcontroller interrupt to falling edge
        SET_FALLING_EDGE__;
        // enable microcontroller interrupt
        ENABLE_VPC3_INT__;

        //todo: before startup the VPC3+, make here your own initialzations

        START_VPC3();
    }
    else
    {
        vpc3_errcb.error_code = error;
        fatal_error( _DP_USER, __LINE__, &vpc3_errcb );
    }//if( DP_OK == error )

    /*-----------------------------------------------------------------------*/
    /* endless demo operation loop                                           */
    /*-----------------------------------------------------------------------*/
    while( 1 )
    {
        /*-------------------------------------------------------------------*/
        /* trigger watchdogs                                                 */
        /*-------------------------------------------------------------------*/
        // toggle user watchdog
        VPC3_RESET_USER_WD();   // toggle user watchdog

        #ifdef RS232_SERIO
            if(rec_counter > 0)
            {
                DISABLE_ALL_INTERRUPT_BIT__;

                print_serial_inputs();

                ENABLE_ALL_INTERRUPT_BIT__;
            }
        #endif//#ifdef RS232_SERIO

        /*-------------------------------------------------------------------*/
        /* internal state machine                                            */
        /*-------------------------------------------------------------------*/
        if( user.state == USER_STATE_CLEAR )
        {
            // clear data
            memset( &sSystem.output.do8[0] , 0, 9 );
            memset( &sSystem.input.di8[0]  , 0, 9 );

            #ifdef EvaBoard_AT89C5132
                bDiagStateModule5  = FALSE;
                bDiagStateModule6  = FALSE;

                *WRITE_PORT1 = 0x00;
                *WRITE_PORT2 = 0x00;
            #endif//#ifdef EvaBoard_AT89C5132

            user.state = USER_STATE_RUN;
        }//if( user.state == USER_STATE_CLEAR )

        /*-------------------------------------------------------------------*/
        /* dpv1 statemachines                                                */
        /*-------------------------------------------------------------------*/
        vpc3_dpv1_statemachine();

        /*-------------------------------------------------------------------*/
        /* VPC3+ DP-state                                                    */
        /*-------------------------------------------------------------------*/
        switch(VPC3_GET_DP_STATE())
        {
            case WAIT_PRM:
            {
                // set LED's
                CLR_LED_YLW__;
                SET_LED_RED__;

                //BugFix 502
                if( ( vpc3_get_master() != 0xFF ) && (( p_Vpc3->isreg.rd.status_L == 0x85 ) || ( p_Vpc3->isreg.rd.status_L == 0x81 )) )
                {
                    GO_OFFLINE_VPC3();
                    do
                    {