Пример #1
0
int main(void)
{


    uint32_t timer1msDiff;  
    uint32_t t;
    static uint32_t timer1msPrevious;

    CO_NMT_reset_cmd_t reset = CO_RESET_NOT;

    HAL_Init();

  /* Configure the system clock to 48 MHz */
     SystemClock_Config();
  
  /* Enable GPIOA Clock                  */
     LED_GPIOA_CLK_ENABLE();

  /* Enable CAN peripherals              */
     CAN_CLK_ENABLE();            
     CAN_GPIO_CLK_ENABLE();
      
    // debug_printf("This is a pass test");
         
  /* Initialize LEDs                     */
    InitCanLeds();  /* -3- Toggle IOs in an infinite loop */

    CanLedsSet(CoLed_Green);
   // CanLedsSet(CoLed_Red);
   // CanLedsSet(CoLed_Blue);
   // CanLedsSet(CoLed_Yellow);
  

  /* Configure Timer interrupt function for execution every 1 ms*/
    TIMER_InitRCC();
    TIMER_InitGeneral();

    /* Program start - Application Call     */
    programStart();


    while (reset != CO_RESET_APP) {
       
    /* disable timer interrupts */
    NVIC_DisableIRQ(TIM2_IRQn);
    
    /* CANopen communication reset - initialize CANopen objects; CanOpen is initialized from within communication reset function */
    communicationReset();   

      /* start Timer interupts*/
      NVIC_EnableIRQ(TIM2_IRQn);

      reset = CO_RESET_NOT;
      timer1msPrevious = timer1ms;

    while (reset == CO_RESET_NOT) {

   /* loop for normal program execution */
      timer1msDiff = timer1ms - timer1msPrevious;
      timer1msPrevious = timer1ms;


    /* Program Async for SDO and NMT messages */
       reset = programAsync(timer1msDiff);


    // t = getTime_us(&tprof);   // 
       t = 100;
       OD_performance[ODA_performance_mainCycleTime] = t;
       if (t > OD_performance[ODA_performance_mainCycleMaxTime])
       OD_performance[ODA_performance_mainCycleMaxTime] = t;

    } /*  while (reset != 0) */
}     /*  while (reset != 2) */
   
    
    /* program exit  */

    CO_DISABLE_INTERRUPTS();

    CanLedsSet(CoLed_None);
    CanLedsSet(CoLed_Red);

    /* delete CANopen object from memory */
    CO_delete();



}
Пример #2
0
//===========================================================================
// CANopen stack main entry point
//===========================================================================
void CO_main(void)
{
	CO_FlashInit();
	while (1)
	{
		reset = CO_RESET_NOT;
		// Application interface
		programStart();

		// increase variable each startup. Variable is stored in EEPROM.
		OD_powerOnCounter++;
		while (reset < CO_RESET_APP)
		{
			// CANopen communication reset - initialize CANopen objects
			int16_t err;
			cyg_uint64 timer1msPrevious = CO_TmrGetMilliSec();

			// initialize CANopen
			err = CO_init();
			if(err)
			{
				CO_eCos_errorReport(CO->em, CO_EM_MEMORY_ALLOCATION_ERROR,
					CO_EMC_SOFTWARE_INTERNAL, err);
				while(1);
			}
			// register object dictionary functions to support store and restore
			// of parameters via objects 0x1010 and 0x1011
			CO_FlashRegisterODFunctions(CO);

			// initialize variables
			reset = CO_RESET_NOT;

			// Application interface
			communicationReset();

			// start CAN and enable interrupts
			CO_CANsetNormalMode(ADDR_CAN1);

			while (CO_RESET_NOT == reset)
			{
				//diag_print_reg("CAN GSR", CAN_CTRL_1_REG_BASE + CANREG_GSR);
				// loop for normal program execution
				cyg_uint64 timer1ms = CO_TmrGetMilliSec();
				uint16_t timer1msDiff = timer1ms - timer1msPrevious;
				timer1msPrevious = timer1ms;

				// Application interface
				programAsync(timer1msDiff);

				// CANopen process
				reset = CO_process(CO, timer1msDiff);
				if (CO_TmrIsExpired(CANopenPollingTimer))
				{
					CANopenPollingTimer = CO_TmrStartFrom(CANopenPollingTimer, 1);
					CO_process_RPDO(CO);
					program1ms();
					CO_process_TPDO(CO);
				}
			}
		}
	}
}
Пример #3
0
/* main ***********************************************************************/
int main (void){
    unsigned int temp_ui;
    CO_NMT_reset_cmd_t reset = CO_RESET_NOT;

    /* Configure system for maximum performance. plib is necessary for that.*/
    /* SYSTEMConfig(CO_FSYS*1000, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE); */

    /* Enable system multi vectored interrupts */
    INTCONbits.MVEC = 1;
    __builtin_enable_interrupts();

    /* Disable JTAG and trace port */
    DDPCONbits.JTAGEN = 0;
    DDPCONbits.TROEN = 0;


    /* Verify, if OD structures have proper alignment of initial values */
    if(CO_OD_RAM.FirstWord != CO_OD_RAM.LastWord) while(1) CO_clearWDT();
    if(CO_OD_EEPROM.FirstWord != CO_OD_EEPROM.LastWord) while(1) CO_clearWDT();
    if(CO_OD_ROM.FirstWord != CO_OD_ROM.LastWord) while(1) CO_clearWDT();


    /* initialize EEPROM - part 1 */
#ifdef USE_EEPROM
    CO_ReturnError_t eeStatus = CO_EE_init_1(&CO_EEO, (uint8_t*) &CO_OD_EEPROM, sizeof(CO_OD_EEPROM),
                            (uint8_t*) &CO_OD_ROM, sizeof(CO_OD_ROM));
#endif


    programStart();


    /* increase variable each startup. Variable is stored in eeprom. */
    OD_powerOnCounter++;


    while(reset != CO_RESET_APP){
/* CANopen communication reset - initialize CANopen objects *******************/
        CO_ReturnError_t err;
        uint16_t timer1msPrevious;
        uint16_t TMR_TMR_PREV = 0;
        uint8_t nodeId;
        uint16_t CANBitRate;

        /* disable timer and CAN interrupts */
        CO_TMR_ISR_ENABLE = 0;
        CO_CAN_ISR_ENABLE = 0;
        CO_CAN_ISR2_ENABLE = 0;

        /* Read CANopen Node-ID and CAN bit-rate from object dictionary */
        nodeId = OD_CANNodeID;
        if(nodeId<1 || nodeId>127) nodeId = 0x10;
        CANBitRate = OD_CANBitRate;/* in kbps */

        /* initialize CANopen */
        err = CO_init(ADDR_CAN1, nodeId, CANBitRate);
        if(err != CO_ERROR_NO){
            while(1) CO_clearWDT();
            /* CO_errorReport(CO->em, CO_EM_MEMORY_ALLOCATION_ERROR, CO_EMC_SOFTWARE_INTERNAL, err); */
        }


        /* initialize eeprom - part 2 */
#ifdef USE_EEPROM
        CO_EE_init_2(&CO_EEO, eeStatus, CO->SDO, CO->em);
#endif


        /* initialize variables */
        timer1msPrevious = CO_timer1ms;
        OD_performance[ODA_performance_mainCycleMaxTime] = 0;
        OD_performance[ODA_performance_timerCycleMaxTime] = 0;
        reset = CO_RESET_NOT;



        /* Configure Timer interrupt function for execution every 1 millisecond */
        CO_TMR_CON = 0;
        CO_TMR_TMR = 0;
        #if CO_PBCLK > 65000
            #error wrong timer configuration
        #endif
        CO_TMR_PR = CO_PBCLK - 1;  /* Period register */
        CO_TMR_CON = 0x8000;       /* start timer (TON=1) */
        CO_TMR_ISR_FLAG = 0;       /* clear interrupt flag */
        CO_TMR_ISR_PRIORITY = 3;   /* interrupt - set lower priority than CAN (set the same value in interrupt) */

        /* Configure CAN1 Interrupt (Combined) */
        CO_CAN_ISR_FLAG = 0;       /* CAN1 Interrupt - Clear flag */
        CO_CAN_ISR_PRIORITY = 5;   /* CAN1 Interrupt - Set higher priority than timer (set the same value in '#define CO_CAN_ISR_PRIORITY') */
        CO_CAN_ISR2_FLAG = 0;      /* CAN2 Interrupt - Clear flag */
        CO_CAN_ISR2_PRIORITY = 5;  /* CAN Interrupt - Set higher priority than timer (set the same value in '#define CO_CAN_ISR_PRIORITY') */


        communicationReset();


        /* start CAN and enable interrupts */
        CO_CANsetNormalMode(ADDR_CAN1);
        CO_TMR_ISR_ENABLE = 1;
        CO_CAN_ISR_ENABLE = 1;

#if CO_NO_CAN_MODULES >= 2
        CO_CANsetNormalMode(ADDR_CAN2);
        CO_CAN_ISR2_ENABLE = 1;
#endif


        while(reset == CO_RESET_NOT){
/* loop for normal program execution ******************************************/
            uint16_t timer1msCopy, timer1msDiff;

            CO_clearWDT();


            /* calculate cycle time for performance measurement */
            timer1msCopy = CO_timer1ms;
            timer1msDiff = timer1msCopy - timer1msPrevious;
            timer1msPrevious = timer1msCopy;
            uint16_t t0 = CO_TMR_TMR;
            uint16_t t = t0;
            if(t >= TMR_TMR_PREV){
                t = t - TMR_TMR_PREV;
                t = (timer1msDiff * 100) + (t / (CO_PBCLK / 100));
            }
            else if(timer1msDiff){
                t = TMR_TMR_PREV - t;
                t = (timer1msDiff * 100) - (t / (CO_PBCLK / 100));
            }
            else t = 0;
            OD_performance[ODA_performance_mainCycleTime] = t;
            if(t > OD_performance[ODA_performance_mainCycleMaxTime])
                OD_performance[ODA_performance_mainCycleMaxTime] = t;
            TMR_TMR_PREV = t0;


            /* Application asynchronous program */
            programAsync(timer1msDiff);

            CO_clearWDT();


            /* CANopen process */
            reset = CO_process(CO, timer1msDiff, NULL);

            CO_clearWDT();


#ifdef USE_EEPROM
            CO_EE_process(&CO_EEO);
#endif
        }
    }


/* program exit ***************************************************************/
//    CO_DISABLE_INTERRUPTS();

    /* delete objects from memory */
    programEnd();
    CO_delete(ADDR_CAN1);

    /* reset */
    SYSKEY = 0x00000000;
    SYSKEY = 0xAA996655;
    SYSKEY = 0x556699AA;
    RSWRSTSET = 1;
    temp_ui = RSWRST;
    while(1);
}
DWORD WINAPI CanOpen_run(LPVOID lpParam)
{
	

	/* initialize EEPROM - part 1 */
#ifdef USE_EEPROM
	CO_ReturnError_t eeStatus = CO_EE_init_1(&CO_EEO, (uint8_t*)&CO_OD_EEPROM, sizeof(CO_OD_EEPROM),
		(uint8_t*)&CO_OD_ROM, sizeof(CO_OD_ROM));
#endif

	programStart();

	/* increase variable each startup. Variable is stored in eeprom. */
	OD_powerOnCounter++;

	while (reset != CO_RESET_APP) {
		/* CANopen communication reset - initialize CANopen objects *******************/
		CO_ReturnError_t err;
		uint16_t timer1msPrevious;
		uint16_t TMR_TMR_PREV = 0;
		uint8_t nodeId;
		uint16_t CANBitRate;

		/* disable CAN and CAN interrupts */
		CO_CAN_ISR_ENABLE = 0;
		CO_CAN_ISR2_ENABLE = 0;

		/* Read CANopen Node-ID and CAN bit-rate from object dictionary */
		nodeId = OD_CANNodeID;
		if (nodeId<1 || nodeId>127) nodeId = 0x10;
		CANBitRate = OD_CANBitRate;/* in kbps */

								   /* initialize CANopen */
		err = CO_init(ADDR_CAN1, nodeId, CANBitRate);
		if (err != CO_ERROR_NO) {
			//FIXME do something here?
			/* CO_errorReport(CO->em, CO_EM_MEMORY_ALLOCATION_ERROR, CO_EMC_SOFTWARE_INTERNAL, err); */
		}


		/* initialize eeprom - part 2 */
#ifdef USE_EEPROM
		CO_EE_init_2(&CO_EEO, eeStatus, CO->SDO[0], CO->em);
#endif


		/* Configure callback functions */
		CO_SYNC_initCallback(CO->SYNC, CANrx_lockCbSync);

		/* initialize variables */
		timer1msPrevious = CO_timer1ms;
		OD_performance[ODA_performance_mainCycleMaxTime] = 0;
		OD_performance[ODA_performance_timerCycleMaxTime] = 0;
		reset = CO_RESET_NOT;

		/* Configure Timer interrupt function for execution every 1 millisecond */
		/* Not sure if this is the best type of timer to use */
		/* The jitter on the timing is not great */
		BOOL success = CreateTimerQueueTimer(
			&m_timerHandle,
			NULL,
			TimerProc,
			NULL,
			0,
			1, //Period in ms
			WT_EXECUTEINTIMERTHREAD);

#if CO_PBCLK > 65000
#error wrong timer configuration
#endif
		communicationReset();

		/* start CAN and enable interrupts */
		CO_CANsetNormalMode(CO->CANmodule[0]);
		
#if CO_NO_CAN_MODULES >= 2
		CO_CANsetNormalMode(CO->CANmodule[1]);
		CO_CAN_ISR2_ENABLE = 1;
#endif


		while (reset == CO_RESET_NOT) {
			/* loop for normal program execution ******************************************/
			uint16_t timer1msCopy, timer1msDiff;

			/* calculate cycle time for performance measurement */
			
			timer1msCopy = CO_timer1ms;
			timer1msDiff = timer1msCopy - timer1msPrevious;
			timer1msPrevious = timer1msCopy;

			LARGE_INTEGER Frequency;
			LARGE_INTEGER StartingTime;
			LARGE_INTEGER ElapsedMicroseconds;

			QueryPerformanceFrequency(&Frequency);
			QueryPerformanceCounter(&StartingTime);
			ElapsedMicroseconds.QuadPart = StartingTime.QuadPart - li_main.QuadPart;
			ElapsedMicroseconds.QuadPart *= 1000000;
			ElapsedMicroseconds.QuadPart /= Frequency.QuadPart;

			double t = ElapsedMicroseconds.QuadPart / 1000.0;
			t = 1000.0 / t;

			OD_performance[ODA_performance_mainCycleTime] = t;

			if (t > OD_performance[ODA_performance_mainCycleMaxTime])
					OD_performance[ODA_performance_mainCycleMaxTime] = t;
	
			li_main = StartingTime;

			/* Application asynchronous program */
			programAsync(timer1msDiff);

			/* Pump the SDO master */
			/* TODO In theory we should support as many masters as is defined in OD*/
			canprocessSDOmaster(timer1msDiff);

			/* CANopen process */
			reset = CO_process(CO, timer1msDiff, NULL);

			Sleep(1); //add some grace time to the thread as we do not want to hammer the async thread at 100%

		}
#ifdef USE_EEPROM
			CO_EE_process(&CO_EEO);
#endif
		}

		/* program exit ***************************************************************/

		/* delete objects from memory */
		programEnd();
		CO_delete(ADDR_CAN1);

		// fix me graceful shutdown on win32
		return 0;
}