Subversion Repositories NaviCtrl

#include <string.h>

#include "91x_lib.h"

#include "91x_can.h"

#include "timer1.h"

#include "led.h"

#include "canbus.h"

#include "main.h"

#include "uart1.h"

#include "GPS.h"

canmsg CanMsg;

canmsg RxCanMsg;

volatile u32 AllMsgsReceived;

GPIO_InitTypeDef    GPIO_InitStructure;

CAN_InitTypeDef     CAN_InitStructure;

typedef  enum {

    NA,

    Priority_1,

    Priority_2,

    Priority_3

  }VIC_Priority;

  /* buffer for receive messages */

  canmsg RxCanTxMsg;

  /* used message object numbers */

  enum {

        CAN_TX_MSGOBJ = 0,

        CAN_RX_MSGOBJ = 1

  };

#define CAN_MSG_ADR     0x100

#define CAN_ID_VERSION  0

#define CAN_ID_STATUS   1

#define CAN_ID_FS_LON   2

#define CAN_ID_FS_LAT   3

#define CAN_ID_FS_ALT   4

#define MAX_CAN_MSG     10

CanMessage_t CanTxMessage[MAX_CAN_MSG];

CanMessage_t CanRxMessage[MAX_CAN_MSG];

void CAN_IO_Init(void)

{

// P5.0 alternate input 1, CAN_RX pin 

        GPIO_StructInit(&GPIO_InitStructure);

        GPIO_InitStructure.GPIO_Pin=GPIO_Pin_0;

        GPIO_InitStructure.GPIO_Direction=GPIO_PinInput;

        GPIO_InitStructure.GPIO_IPInputConnected=GPIO_IPInputConnected_Enable;

        GPIO_InitStructure.GPIO_Alternate=GPIO_InputAlt1;

        GPIO_Init(GPIO5,&GPIO_InitStructure);

// P5.1 CAN_TX

        GPIO_StructInit(&GPIO_InitStructure);

        GPIO_InitStructure.GPIO_Pin=GPIO_Pin_1;

        GPIO_InitStructure.GPIO_Direction=GPIO_PinOutput;

        GPIO_InitStructure.GPIO_Type=GPIO_Type_PushPull;

        GPIO_InitStructure.GPIO_Alternate=GPIO_OutputAlt2;

        GPIO_Init(GPIO5,&GPIO_InitStructure);

}

/*******************************************************************************

* Function Name  : CAN_IRQHandler

* Description    : This function handles the CAN interrupt request

*******************************************************************************/

void CAN_IRQHandler(void)

{

   u32 msgobj = 0;

  if(CAN->IDR == 0x8000)        /* status interrupt */

  {

    (void)CAN->SR;      /* read the status register to clear*/

  }

  else if(CAN->IDR >= 1 && CAN->IDR <= 32)

  {

    /* get the message object number that caused the interrupt to occur */

    switch(msgobj = CAN->IDR - 1)

    {

      case  0 /* CAN_TX_MSGOBJ */:

                CAN_ReleaseTxMessage(msgobj);

        break;

      case 1 /* CAN_RX_MSGOBJ */:

        CAN_ReceiveMessage(msgobj, FALSE, &RxCanMsg);

                CAN_ReleaseRxMessage(msgobj);

                if(RxCanMsg.Id >= CAN_MSG_ADR && RxCanMsg.Id < CAN_MSG_ADR + MAX_CAN_MSG)

                 {

                        memcpy(&CanRxMessage[RxCanMsg.Id - CAN_MSG_ADR], &RxCanMsg,sizeof(RxCanMsg));

                 }

                if(RxCanMsg.Id == CAN_MSG_ADR + MAX_CAN_MSG - 1)

                 {

                  AllMsgsReceived = 1;

                 }

                DebugOut.Analog[16] = RxCanMsg.Id;

  break;

      default:

        CAN_ReleaseMessage(msgobj);

        break;

    }

  }

   /*write any value to VIC0 VAR*/  

   VIC0->VAR = 0xFF;   

}

void CanSend(void)

{

static u32 index = 1;

CanTxMessage[4].D.sLong = DebugOut.Analog[24];

//  CAN_SendMessage(CAN_TX_MSGOBJ, &TxCanMsg[1]);

  if(CAN_SendMessage(CAN_TX_MSGOBJ, &CanTxMessage[index]) == SUCCESS)

   {

    if(++index >= MAX_CAN_MSG)

         {

                index = 0;

                CanTxMessage[CAN_ID_FS_LON].D.sLong = GPS_FailsafePosition.Longitude;

                CanTxMessage[CAN_ID_FS_LAT].D.sLong = GPS_FailsafePosition.Latitude;

         }

   }

}

void CanReceive(void)

{

}

void CanbusInit(void)

{

 UART1_PutString("\r\n Canbus init...");

 CAN_IO_Init();

 SCU_APBPeriphClockConfig(__CAN, ENABLE);

 SCU_APBPeriphReset(__CAN, DISABLE);

 VIC_Config(CAN_ITLine, VIC_IRQ, Priority_1);

 CAN_InitStructure.CAN_ConfigParameters=CAN_CR_IE;

 CAN_InitStructure.CAN_Bitrate = CAN_BITRATE_1M;

 CAN_Init(&CAN_InitStructure);

 VIC_ITCmd(CAN_ITLine, ENABLE);

 CAN_SetUnusedAllMsgObj();

 CAN_SetTxMsgObj(CAN_TX_MSGOBJ, CAN_STD_ID, DISABLE);

 CAN_SetRxMsgObj(CAN_RX_MSGOBJ, CAN_STD_ID, 0, CAN_LAST_STD_ID, TRUE);

u32 i;

for(i=0; i< MAX_CAN_MSG;i++)

 {

        CanTxMessage[i].IdType = CAN_STD_ID;

        CanTxMessage[i].Id = i + CAN_MSG_ADR;

        CanTxMessage[i].Length = 8;

        CanTxMessage[i].D.Long = i;

 }

CanTxMessage[CAN_ID_VERSION].D.Byte[0]  = CAN_SLAVE_COMPATIBLE;

CanTxMessage[CAN_ID_VERSION].D.Byte[1]  = VERSION_PATCH;

CanTxMessage[CAN_ID_VERSION].D.Byte[2]  = VERSION_MINOR;

CanTxMessage[CAN_ID_VERSION].D.Byte[3]  = VERSION_MAJOR;

 UART1_PutString("ok");

}

void ProcessCanBus(void)

{

 CanSend();

 CanReceive();

if(CAN_GetTransmitErrorCounter() > 200) CanbusInit();

//DebugOut.Analog[16] = CAN->SR ;

if(AllMsgsReceived)

 {

  AllMsgsReceived = 0;

  DebugOut.Analog[17] = CanRxMessage[4].D.sLong;

  DebugOut.Analog[19]++;       

DebugOut.Analog[17] = CanRxMessage[CAN_ID_FS_LON].D.sLong / 100000;

DebugOut.Analog[18] = CanRxMessage[CAN_ID_FS_LAT].D.sLong / 100000;

if(DebugOut.Analog[31] == 0)

  {

                GPS_FailsafePosition.Longitude = CanRxMessage[CAN_ID_FS_LON].D.sLong;

                GPS_FailsafePosition.Latitude = CanRxMessage[CAN_ID_FS_LAT].D.sLong;

  }

 }

}