예제 #1
0
파일: Can.c 프로젝트: paduc77/gainos
EXPORT void Can_InitController(uint8 Controller,const Can_ControllerConfigType* Config)
{
	Can_UnitType *canUnit;
	StatusType ercd;
	canUnit = CAN_GET_PRIVATE_DATA(Controller);
#if(CAN_DEV_ERROR_DETECT == STD_ON)
	if(CAN_UNINIT == Can_Global.driverState)
	{
		Det_ReportError(MODULE_ID_CAN,0,CAN_INITCONTROLLER_SERVICE_ID,CAN_E_UNINIT);
		return;
	}
	if(NULL == Config)
	{
		Det_ReportError(MODULE_ID_CAN,0,CAN_INITCONTROLLER_SERVICE_ID,CAN_E_PARAM_POINTER);
		return;
	}
	if(Controller >= CAN_CONTROLLER_CNT)
	{
		Det_ReportError(MODULE_ID_CAN,0,CAN_INITCONTROLLER_SERVICE_ID,CAN_E_PARAM_CONTROLLER);
		return;
	}
	if(canUnit->state!=CANIF_CS_STOPPED)
	{
		Det_ReportError(MODULE_ID_CAN,0,CAN_INITCONTROLLER_SERVICE_ID,CAN_E_TRANSITION);
		return;
	}
#endif
	ercd = Can_Hw_InitController(Controller,Config);
	if(ercd != E_OK)
	{
		return;
	}
	canUnit->state = CANIF_CS_STOPPED;
	Can_EnableControllerInterrupts(Controller);
}
예제 #2
0
파일: Can_Hw.c 프로젝트: SushMJ/gainos-tk
EXPORT Can_ReturnType Can_Hw_SetControllerMode(uint8 controller,Can_StateTransitionType transition)
{
	  imask_t state;
	  CAN_HW_t *canHw;
	  Can_ReturnType rv = CAN_OK;

	  Can_UnitType *canUnit = CAN_GET_PRIVATE_DATA(controller);

	  VALIDATE( (canUnit->state!=CANIF_CS_UNINIT), 0x3, CAN_E_UNINIT );
	  canHw = GetController(controller);

	  switch(transition )
	  {
	  case CAN_T_START:
	    canUnit->state = CANIF_CS_STARTED;
	    Irq_Save(state);
	    if (canUnit->lock_cnt == 0){   // REQ CAN196
	      Can_EnableControllerInterrupts(controller);
	    }
	    Irq_Restore(state);
	    break;
	  case CAN_T_WAKEUP:
		VALIDATE(canUnit->state == CANIF_CS_SLEEP, 0x3, CAN_E_TRANSITION);
		CAN_WakeUp(canHw);
		canUnit->state = CANIF_CS_STOPPED;
		break;
	  case CAN_T_SLEEP:  //CAN258, CAN290
	    // Should be reported to DEM but DET is the next best
	    VALIDATE(canUnit->state == CANIF_CS_STOPPED, 0x3, CAN_E_TRANSITION);
	    CAN_Sleep(canHw);
	    canUnit->state = CANIF_CS_SLEEP;
		break;
	  case CAN_T_STOP:
	    // Stop
	    canUnit->state = CANIF_CS_STOPPED;
	    Can_AbortTx( canHw, canUnit ); // CANIF282
	    break;
	  default:
	    // Should be reported to DEM but DET is the next best
	    VALIDATE(canUnit->state == CANIF_CS_STOPPED, 0x3, CAN_E_TRANSITION);
	    break;
	  }

	  return rv;
}
예제 #3
0
파일: Can_Hw.c 프로젝트: SushMJ/gainos-tk
EXPORT Std_ReturnType Can_Hw_InitController(uint8 controller,const Can_ControllerConfigType* config)
{
	  CAN_HW_t *canHw;
	  uint8_t tq;
	  uint8_t tqSync;
	  uint8_t tq1;
	  uint8_t tq2;
	  uint32_t clock;
	  Can_UnitType *canUnit;
	  uint8 cId = controller;
	  const Can_ControllerConfigType *canHwConfig;
	  const Can_HardwareObjectType *hohObj;


	  canUnit = CAN_GET_PRIVATE_DATA(controller);

	  canHw = GetController(cId);
	  canHwConfig = CAN_GET_CONTROLLER_CONFIG(Can_Global.channelMap[cId]);

	  // Start this baby up
	  CAN_DeInit(canHw);

	  /* CAN filter init. We set up two filters - one for the master (CAN1) and
	   * one for the slave (CAN2)
	   *
	   * CAN_SlaveStartBank(n) denotes which filter is the first of the slave.
	   *
	   * The filter registers reside in CAN1 and is shared to CAN2, so we only need
	   * to set up this once.
	   */

	  // We let all frames in and do the filtering in software.
	  CAN_FilterInitTypeDef  CAN_FilterInitStructure;
	  CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;
	  CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;
	  CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;
	  CAN_FilterInitStructure.CAN_FilterIdLow=0x0000;
	  CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;
	  CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;
	  CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;
	  CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;

	  // Init filter 0 (CAN1/master)
	  CAN_FilterInitStructure.CAN_FilterNumber=0;
	  CAN_FilterInit(&CAN_FilterInitStructure);

	  // Init filter 1 (CAN2/slave)
	  CAN_FilterInitStructure.CAN_FilterNumber=1;
	  CAN_FilterInit(&CAN_FilterInitStructure);

	  // Set which filter to use for CAN2.
	  CAN_SlaveStartBank(1);

	  // acceptance filters
	   hohObj = canHwConfig->Can_Hoh;
	   --hohObj;
	   do {
		 ++hohObj;
	     if (hohObj->CanObjectType == CAN_OBJECT_TYPE_RECEIVE)
	     {
	    	 // TODO Hw filtering
	     }
	   }while( !hohObj->Can_EOL );

	  // Clock calucation
	  // -------------------------------------------------------------------
	  //
	  // * 1 TQ = Sclk period( also called SCK )
	  // * Ftq = Fcanclk / ( PRESDIV + 1 ) = Sclk
	  //   ( Fcanclk can come from crystal or from the peripheral dividers )
	  //
	  // -->
	  // TQ = 1/Ftq = (PRESDIV+1)/Fcanclk --> PRESDIV = (TQ * Fcanclk - 1 )
	  // TQ is between 8 and 25
	  clock = McuE_GetSystemClock()/2;

	  tqSync = config->CanControllerPropSeg + 1;
	  tq1 = config->CanControllerSeg1 + 1;
	  tq2 = config->CanControllerSeg2 + 1;
	  tq = tqSync + tq1 + tq2;

	  CAN_InitTypeDef        CAN_InitStructure;
	  CAN_StructInit(&CAN_InitStructure);

	  /* CAN cell init */
	  CAN_InitStructure.CAN_TTCM=DISABLE;
	  CAN_InitStructure.CAN_ABOM=ENABLE;
	  CAN_InitStructure.CAN_AWUM=ENABLE;
	  CAN_InitStructure.CAN_NART=DISABLE;
	  CAN_InitStructure.CAN_RFLM=DISABLE;
	  CAN_InitStructure.CAN_TXFP=DISABLE;
	  if(config->Can_Loopback){
		  CAN_InitStructure.CAN_Mode=CAN_Mode_LoopBack;
	  }else{
		  CAN_InitStructure.CAN_Mode=CAN_Mode_Normal;
	  }

	  CAN_InitStructure.CAN_SJW=config->CanControllerPropSeg;
	  CAN_InitStructure.CAN_BS1=config->CanControllerSeg1;
	  CAN_InitStructure.CAN_BS2=config->CanControllerSeg2;
	  CAN_InitStructure.CAN_Prescaler= clock/(config->CanControllerBaudRate*1000*tq);

	  if(CANINITOK != CAN_Init(canHw,&CAN_InitStructure))
	  {
		return E_NOT_OK;
	  }

	  canUnit->state = CANIF_CS_STOPPED;
	  Can_EnableControllerInterrupts(cId);

	  return E_OK;
}