Esempio n. 1
0
int test_timer_pit_init(void)
{
	INTC_InitINTCInterrupts();
//	Config_PLL();
	init_PIT_RTI();
	enableIrq();	
}
Esempio n. 2
0
/*~~~~~~~ Main Code ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
int main(void) 

{
	initModesAndClock();
	/* Disable Watchdog */
	disableWatchdog();
	/*Initialize LEDs on TRK-MPC560xB board */
	vfnGPIO_LED_Init();	
	/*Initialize PUSHs on TRK-MPC560xB board */
	vfnGPIO_PUSH_Init();
	/*Initialize Interrupts */
	INTC_InitINTCInterrupts();
	/*Initialize Exception Handlers */
	EXCEP_InitExceptionHandlers();
	
	PIT_device_init();
    PIT_channel_configure(PIT_CHANNEL_0 , dummy_500us);	
    PIT_channel_start(PIT_CHANNEL_0);
    
    /* Enable External Interrupts*/
    enableIrq();
    
	/* Infinite loop */
	dummy_endless_loop();
	for (;;) 
	{
        BackgroundSubsystemTasks();
	}
}
Esempio n. 3
0
int test_timer_RIT_init(void)
{

	Config_PLL();
	INTC_InitINTCInterrupts();
	initPIT_RTI();
	gpio_init(LED_PORT, GPIO_OUTPUT);
	enableIrq();
}
Esempio n. 4
0
int main(void) {
	int i;
	
	InitModesClocks();
	
	INTC_InitINTCInterrupts();
	
	INTC_InstallINTCInterruptHandler(interrutsion,59,1);
	
	INTC.CPR.R=0;
	
	GPIOport(68);
	GPIOport(69);
	GPIOport(70);
	GPIOport(71);
	
	GPIO_out(68);
	GPIO_out(69);
	GPIO_out(70);
	GPIO_out(71);
	
	
	for( i = 0 ; i < E_TotalTsk ; i++ )
	{
		ar_dynamic[i] = ar_tsk[i].offset;
	}
	
	PITconfig();
	PITchannelinterrupt(0,1);
	PITchanneltimeout(0,64000);
	PITcounterReset(0);
	PITintflagReset(0);
	PITstart(0);
	
	
	
	while(1)
	{
		if(flagISR)
		{
			flagISR = 0;
			
			for( i = 0 ; i < E_TotalTsk ; i++ )
			{
				if( ar_dynamic[i] > 0 )
				{
					ar_dynamic[i]--;
				}
				else 
				{
					ar_dynamic[i] = ar_tsk[i].period;
					ar_tsk[i].tskPtr();
				}
			}
		}
	}
}
Esempio n. 5
0
/*~~~~~~~ Main Code ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
void main(void) 

{
	initModesAndClock();
	initPeriClkGen();
	
	/* Disable Watchdog */
	init_disableWatchdog();
	
	/*Initialize LEDs on TRK-MPC560xB board */
	init_OnBoardLEDs();
	
	/*Initialize the On-Board push buttons*/
	init_OnBoardPushButtons();
	
	/*Initialize Interrupts */
	INTC_InitINTCInterrupts();
	/*Initialize Exception Handlers */
	EXCEP_InitExceptionHandlers();
    
    IntcInterruptLINFLEXHandlers();
    
    InitLinFlex0Slave(9600);
    
    LED_Off(LED1);
    LED_Off(LED2);
    LED_Off(LED3);
    LED_Off(LED4);
    
    /*Initialize scheduler*/	
    SchM_Init(&SchConfig);
    
    /*Hand control to the scheduler*/
    SchM_Start();
    
    for(;;)
    {
    	
    }
}
Esempio n. 6
0
/*~~~~~~~ Main Code ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
int main(void)

{


    initModesAndClock();
    /* Disable Watchdog */
    disableWatchdog();
    /*Initialize LEDs on TRK-MPC560xB board */

    MemAllocInit(&MemAllocConfig);

    vfnGPIO_LED_Init();
    /*Initialize Interrupts */
    INTC_InitINTCInterrupts();
    /*Initialize Exception Handlers */
    EXCEP_InitExceptionHandlers();

//	PIT_device_init();
    //  PIT_channel_configure(PIT_CHANNEL_0 , Test);
    //  PIT_channel_start(PIT_CHANNEL_0);

    /* Enable External Interrupts*/
    enableIrq();

    /* Infinite loop */


    SchM_Init(&SchedulerConfig);
    SchM_Start();


    for (;;)
    {


        BackgroundSubsystemTasks();
    }
}
Esempio n. 7
0
/*~+:Main Code*/
int main(void) 

{
	/*Enable peri set 1 sysclk divided by 1 */
	
	/* Mode initializations */
	sysinit_InitMode();
	/* Clock initializations */
	sysinit_InitSysClock();
	/* Memory Allcoation Initialization */
	MemAllocInit(&MemAllocConfig);
	/*Initialize LEDs on TRK-MPC560xB board */
	vfnGPIO_LED_Init(); 
	/* SBC dependencies */
	InitDSPI_1();
	ConfigureMZC33905DSPI_1();
	/* CAN Initialization */
	CAN_Initialization(&can_driver_config);
	/* Initialize Interrupts */
	INTC_InitINTCInterrupts();
	/*Initialize Exception Handlers */
	EXCEP_InitExceptionHandlers();
	/* SchM Initialization */
	SchM_Init(&SchMConfig);
    /* Enable External Interrupts*/
    enableIrq();
    /*Selection of type of Car*/
    Light_Ctrl_HwConfig();
    
    init_ADC0_P0();
    /* SchM Start */
    SchM_Start();
	/* Infinite loop - Should never reach this point */
	for (;;) 
	{

	}
}
Esempio n. 8
0
/*~~~~~~~ Main Code ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
int main(void) 

{
	initModesAndClock();
	/* Disable Watchdog */
	disableWatchdog();
	MemAllocInit(&MemAllocConfig);
	
	Init_LIN_SLV1();	
	/*Initialize Interrupts */
	INTC_InitINTCInterrupts();
	/*Initialize Exception Handlers */
	EXCEP_InitExceptionHandlers();
    /* Enable External Interrupts*/
    enableIrq();
	/* Infinite loop */
	/*init del scheduler*/
    SchM_Init(&SchConfig);
    SchM_Start();
	for (;;) 
	{
        BackgroundSubsystemTasks();
	}
}
Esempio n. 9
0
void main(void) {
  volatile uint32_t IdleCtr = 0; 
  
  initModesAndClks();      /* Initialize mode entries */
  initPeriClkGen();        /* Initialize peripheral clock generation for LINFlex */
  disableWatchdog();       /* Disable watchdog */
  
  INTC_InitINTCInterrupts();
  EXCEP_InitExceptionHandlers();
  
  INTC.MCR.R=0;
  INTC_InstallINTCInterruptHandler(&Intc_LINFLEX_Rx, 79, 10);
  INTC_InstallINTCInterruptHandler(&Intc_LINFLEX_Tx, 80, 10);
  INTC_InstallINTCInterruptHandler(&Intc_LINFLEX_Err, 81, 10);
  
  
  INTC.CPR.R = 0;
  
  initLINFlex_0(9600);         /* Initialize FLEXCAN 0 as master */
  NormalModeLINFLEX_2();
  
  //transmitLINframe();     /* Transmit one frame from master */
  while (1) {IdleCtr++;}   /* Idle loop: increment counter */
}
Esempio n. 10
0
void main (void) {      
        volatile uint32_t i = 0;                        /* Dummy idle counter */
        uint8_t success=0;
        uint8_t byteReceived=0;
        uint8_t opcode=0;
        uint8_t payload=0;
        char    msg[32];
        uint8_t msgLength=0;
        clock = 0;
          
        initModesAndClock();  /* MPC56xxP/B/S: Initialize mode entries, set sysclk = 64 MHz*/
        initPeriClkGen();       /* Initialize peripheral clock generation for DSPIs */
        disableWatchdog();    /* Disable watchdog */
        EXCEP_InitExceptionHandlers();          /* Initialize exceptions: only need to load IVPR */
        initADC();
        initPIT();                      /* Initialize PIT1 for 10Hz IRQ, priority 2 */
        initPads();                     /* Initialize software interrupt 4 */
        initEMIOS_0();        /* Initialize eMIOS channels as counter, SAIC, OPWM */
        initEMIOS_1();        /* Initialize eMIOS channels as counter, SAIC, OPWM */
                        
        initEMIOS_0ch0();       /* Initialize eMIOS 0 channel 0 as modulus counter*/
        initEMIOS_0ch23();      /* Initialize eMIOS 0 channel 23 as modulus counter*/
        initEMIOS_0ch8();       /* Initialize eMIOS 0 channel 8 as modulus counter*/
        
        
        //just to make sure the wheels are facing straight
        initDrive();
        Drive();
        
        SIU.PCR[64].R = 0x0100;                         /* Program the drive enable pin of S1 (PE0) as input*/
        while((SIU.PGPDI[2].R & 0x80000000) == 0x80000000); /*Wait until S1 switch is pressed*/
        for(i=0;i<100000;i++);
        while((SIU.PGPDI[2].R & 0x80000000) != 0x80000000); /*Wait until S1 switch is released*/
          
        INTC_InitVector();
        INTC_InstallINTCInterruptHandler(&SwIrq4ISR,4,3);
        INTC_InstallINTCInterruptHandler(&EOC_ISR,62,5);
        INTC_InstallINTCInterruptHandler(&Pit1ISR,60,2);
        INTC_InstallINTCInterruptHandler(&Pit2ISR,61,4);
        INTC_InstallINTCInterruptHandler(&Pit3ISR,127,4);
        
        initSerial();
          
        flag_lineDone = -1;
        initCamera();
        
        initSteeringController();
        
        INTC_InitINTCInterrupts();
        INTC.CPR.B.PRI = 0;          /* Single Core: Lower INTC's current priority */
          
        initDrive();
        
//      setPWMRw(48);
//      setPWMLw(48);
        setDirection(FORWARD);
                
        in = getInBuffer();
        out = getOutBuffer();
                
        MESSAGE("I'm running\n\r");
        fifo_write(&out->fifo,msg,msgLength);
        
        while(isCameraReady()!=STATE_READY);
 
        for(;;)
        {               
                if(!(flag_lineDone==1))
                {
                        Drive();
                        success=0;
                        success = fifo_read(&in->fifo,&byteReceived,1);
                        if(success==1)
                        {
                                if(opcode==0)
                                {
                                        opcode = byteReceived;
                                        MESSAGE("Command Received: ");
                                        fifo_write(&out->fifo,msg,msgLength);
                                }
                                else
                                {
                                        payload = byteReceived;
                                        switch(opcode)
                                        {
                                                case DRIVE:
        //                                              TransmitData("Drive Command\n\r");
                                                        MESSAGE("Drive Command\n\r");
                                                        fifo_write(&out->fifo,msg,msgLength);
                                                        setDirection(payload);
                                                        break;
                                                case SET_SPEED:
        //                                              TransmitData("Set Speed Command\n\r");
                                                        MESSAGE("Set Speed Command\n\r");
                                                        fifo_write(&out->fifo,msg,msgLength);
                                                        setPWMRw(payload);
                                                        setPWMLw(payload);
                                                        break;
                                                case STEERING:
        //                                              TransmitData("Set Steering Command\n\r");
                                                        MESSAGE("Set Steering Command\n\r");
                                                        fifo_write(&out->fifo,msg,msgLength);
                                                        setAngle(payload);
                                                        break;
                                                default:
        //                                              TransmitData("Bad command\n\r");
                                                        MESSAGE("Bad command\n\r");
                                                        fifo_write(&out->fifo,msg,msgLength);
                                                        break;
                                        }
                                        opcode = 0;
                                }
                        }
                }
                
                if(TRANSMISSION_DONE()&&(out->fifo.length>0))
                        Tx();
                
                if(RECEPTION_DONE()&&(in->fifo.length<IN_BUFFER_SIZE))
                        Rx();

        }       
}