WebSVN - NaviCtrl - Diff - Rev 721 and 766


#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include "91x_lib.h"
#include "91x_can.h"
#include "timer1.h"
#include "led.h"
#include "canbus.h"
#include "compass.h"
#include "main.h"
#include "uart0.h"
#include "uart1.h"
#include "GPS.h"
 
canmsg CanMsg;
canmsg RxCanMsg;
volatile u32 AllMsgsReceived;
u32 CanbusTimeOut = 0;
 
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_MA  0x200
#define CAN_MSG_ADR_SL  0x300
 
u32 CAN_IdTx; // I am Sending in this ID-Range
u32 CAN_IdRx; // I am Receiving in this ID-Range
 
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_IdRx && RxCanMsg.Id < CAN_IdRx + MAX_CAN_MSG)
                 {
                        memcpy(&CanRxMessage[RxCanMsg.Id - CAN_IdRx], &RxCanMsg,sizeof(RxCanMsg));
                 }
                if(RxCanMsg.Id == CAN_IdRx + MAX_CAN_MSG - 1)
                 {
                  AllMsgsReceived = 1;
                 }
//              DebugOut.Analog[] = RxCanMsg.Id;
  break;
 
      default:
        CAN_ReleaseMessage(msgobj);
        break;
    }
  }
   
   /*write any value to VIC0 VAR*/  
   VIC0->VAR = 0xFF;   
 
}
 
void CanSend(void)
{
static u32 index = 1;
 
  if(CAN_SendMessage(CAN_TX_MSGOBJ, (canmsg*) &CanTxMessage[index]) == SUCCESS)
   {
    if(++index >= MAX_CAN_MSG)
         {
                u32 i;
                index = 0;
                CanTxMessage[CAN_ID_STATUS].D.Byte[0] = ErrorCode;
 
                CanTxMessage[CAN_ID_FS_LON].D.sLong[0] = GPS_FailsafePosition.Longitude;
                CanTxMessage[CAN_ID_FS_LAT].D.sLong[0] = GPS_FailsafePosition.Latitude;
 
                CanTxMessage[CAN_ID_STATUS].D.Byte[0] = ErrorCode;
                CanTxMessage[CAN_ID_STATUS].D.Byte[1] = FC.StatusFlags;
                CanTxMessage[CAN_ID_STATUS].D.Byte[2] = FC.StatusFlags2;
                CanTxMessage[CAN_ID_STATUS].D.Byte[3] = FC.StatusFlags3;
                CanTxMessage[CAN_ID_STATUS].D.Byte[4] = NC_To_FC_Flags;
                CanTxMessage[CAN_ID_STATUS].D.Byte[5] = EarthMagneticField/5; // in %
                CanTxMessage[CAN_ID_STATUS].D.Int[3]  = GyroCompassCorrected;
 
                for(i=0; i<8;i++)
                 {
                  CanTxMessage[CAN_ID_TEXT1].D.Byte[i] = ErrorMSG[i];
                  CanTxMessage[CAN_ID_TEXT2].D.Byte[i] = ErrorMSG[i + 8];
                  CanTxMessage[CAN_ID_TEXT3].D.Byte[i] = ErrorMSG[i + 16];
                 }                                                                               
         }
   }
}
 
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;
 
if(IamMaster == SLAVE)
{
 CAN_IdRx = CAN_MSG_ADR_MA;
 CAN_IdTx = CAN_MSG_ADR_SL;
}
else
{
 CAN_IdRx = CAN_MSG_ADR_SL;
 CAN_IdTx = CAN_MSG_ADR_MA;
}
 
for(i=0; i< MAX_CAN_MSG;i++)
 {
        // clear TX Buffer
        CanTxMessage[i].IdType = CAN_STD_ID;
        CanTxMessage[i].Id = i + CAN_IdTx;
        CanTxMessage[i].Length = 8;
        CanTxMessage[i].D.Long[0] = 0;
 
        // clear receiving Buffer
        CanRxMessage[i].Id = 0;
        CanRxMessage[i].D.Long[0] = 0;
 }
 
        CanTxMessage[CAN_ID_VERSION].D.Byte[0]  = 0;
        CanTxMessage[CAN_ID_VERSION].D.Byte[1]  = Parameter.ActiveSetting;
        CanTxMessage[CAN_ID_VERSION].D.Byte[2]  = GPS_Version/1000;
        CanTxMessage[CAN_ID_VERSION].D.Byte[3]  = UART_VersionInfo.HWMajor;
        CanTxMessage[CAN_ID_VERSION].D.Byte[4]  = CAN_SLAVE_COMPATIBLE;
        CanTxMessage[CAN_ID_VERSION].D.Byte[5]  = VERSION_PATCH;
        CanTxMessage[CAN_ID_VERSION].D.Byte[6]  = VERSION_MINOR;
        CanTxMessage[CAN_ID_VERSION].D.Byte[7]  = VERSION_MAJOR;
 
 UART1_PutString("ok");
}
 
void ProcessCanBus(void)
{
 u32 errorcnt = 0;
 
 CanSend();
 CanReceive();
 
 errorcnt = CAN_GetTransmitErrorCounter();
//if(errorcnt > 200) CanbusInit();
 
if(CanbusTimeOut < 3)
{
  if(CanbusTimeOut == 1) Partner.ErrorCode = 39; // ERR: Canbus
  Partner.StatusFlags = 0;
  Partner.StatusFlags2 = 0;
  Partner.StatusFlags3 = 0;
  Partner.NC_To_FC_Flags = 0;
  Partner.MagnetField = 0;
  Partner.GyroCompassCorrected = -1;
  sprintf(PartnerErrorMSG,"     ---                ");
}
 
if(CanRxMessage[CAN_ID_VERSION].D.Byte[6] == 13) // dann ist der Testdummy angeschlossen -> nur zum Testen von EXT2
 {
  if((PartnerErrorMSG[17] + PartnerErrorMSG[18]) & 1) EXT2_ON;
  else EXT2_OFF;
 }
 
if(AllMsgsReceived)
 {
  u32 i;
  AllMsgsReceived = 0;
  CanbusTimeOut = 1000;
  for(i=0; i<8;i++)
   {
          PartnerErrorMSG[i]    = CanRxMessage[CAN_ID_TEXT1].D.Byte[i];
          PartnerErrorMSG[i+8]  = CanRxMessage[CAN_ID_TEXT2].D.Byte[i];
          PartnerErrorMSG[i+16] = CanRxMessage[CAN_ID_TEXT3].D.Byte[i];
   }                                                                             
  Partner.ErrorCode                     = CanRxMessage[CAN_ID_STATUS].D.Byte[0];
  Partner.StatusFlags                   = CanRxMessage[CAN_ID_STATUS].D.Byte[1];
  Partner.StatusFlags2                  = CanRxMessage[CAN_ID_STATUS].D.Byte[2];
  Partner.StatusFlags3                  = CanRxMessage[CAN_ID_STATUS].D.Byte[3];
  Partner.NC_To_FC_Flags                = CanRxMessage[CAN_ID_STATUS].D.Byte[4];
  Partner.MagnetField                   = CanRxMessage[CAN_ID_STATUS].D.Byte[5];
  Partner.GyroCompassCorrected  = CanRxMessage[CAN_ID_STATUS].D.Int[3];
 
  CanTxMessage[CAN_ID_VERSION].D.Byte[1] = Parameter.ActiveSetting;
 
if(IamMaster == SLAVE)
  {
                GPS_FailsafePosition.Longitude = CanRxMessage[CAN_ID_FS_LON].D.sLong[0];
                GPS_FailsafePosition.Latitude = CanRxMessage[CAN_ID_FS_LAT].D.sLong[0];
  }
 }
}                                        
 
 
 
 
 
 

Rev 721	Rev 766
1	#include <stdio.h>	1	#include <stdio.h>
2	#include <stdarg.h>	2	#include <stdarg.h>
3	#include <string.h>	3	#include <string.h>
4	#include "91x_lib.h"	4	#include "91x_lib.h"
5	#include "91x_can.h"	5	#include "91x_can.h"
6	#include "timer1.h"	6	#include "timer1.h"
7	#include "led.h"	7	#include "led.h"
8	#include "canbus.h"	8	#include "canbus.h"
9	#include "compass.h"	9	#include "compass.h"
10	#include "main.h"	10	#include "main.h"
11	#include "uart0.h"	11	#include "uart0.h"
12	#include "uart1.h"	12	#include "uart1.h"
13	#include "GPS.h"	13	#include "GPS.h"
14		14
15	canmsg CanMsg;	15	canmsg CanMsg;
16	canmsg RxCanMsg;	16	canmsg RxCanMsg;
17	volatile u32 AllMsgsReceived;	17	volatile u32 AllMsgsReceived;
18	u32 CanbusTimeOut = 0;	18	u32 CanbusTimeOut = 0;
19		19
20	GPIO_InitTypeDef GPIO_InitStructure;	20	GPIO_InitTypeDef GPIO_InitStructure;
21	CAN_InitTypeDef CAN_InitStructure;	21	CAN_InitTypeDef CAN_InitStructure;
22		22
23		23
24	typedef enum {	24	typedef enum {
25	NA,	25	NA,
26	Priority_1,	26	Priority_1,
27	Priority_2,	27	Priority_2,
28	Priority_3	28	Priority_3
29	}VIC_Priority;	29	}VIC_Priority;
30		30
31	/* buffer for receive messages */	31	/* buffer for receive messages */
32	canmsg RxCanTxMsg;	32	canmsg RxCanTxMsg;
33		33
34	/* used message object numbers */	34	/* used message object numbers */
35	enum {	35	enum {
36	CAN_TX_MSGOBJ = 0,	36	CAN_TX_MSGOBJ = 0,
37	CAN_RX_MSGOBJ = 1	37	CAN_RX_MSGOBJ = 1
38	};	38	};
39		39
40	#define CAN_MSG_ADR_MA 0x200	40	#define CAN_MSG_ADR_MA 0x200
41	#define CAN_MSG_ADR_SL 0x300	41	#define CAN_MSG_ADR_SL 0x300
42		42
43	u32 CAN_IdTx; // I am Sending in this ID-Range	43	u32 CAN_IdTx; // I am Sending in this ID-Range
44	u32 CAN_IdRx; // I am Receiving in this ID-Range	44	u32 CAN_IdRx; // I am Receiving in this ID-Range
45		45
46	CanMessage_t CanTxMessage[MAX_CAN_MSG];	46	CanMessage_t CanTxMessage[MAX_CAN_MSG];
47	CanMessage_t CanRxMessage[MAX_CAN_MSG];	47	CanMessage_t CanRxMessage[MAX_CAN_MSG];
48		48
49	void CAN_IO_Init(void)	49	void CAN_IO_Init(void)
50	{	50	{
51	// P5.0 alternate input 1, CAN_RX pin	51	// P5.0 alternate input 1, CAN_RX pin
52	GPIO_StructInit(&GPIO_InitStructure);	52	GPIO_StructInit(&GPIO_InitStructure);
53	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_0;	53	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_0;
54	GPIO_InitStructure.GPIO_Direction=GPIO_PinInput;	54	GPIO_InitStructure.GPIO_Direction=GPIO_PinInput;
55	GPIO_InitStructure.GPIO_IPInputConnected=GPIO_IPInputConnected_Enable;	55	GPIO_InitStructure.GPIO_IPInputConnected=GPIO_IPInputConnected_Enable;
56	GPIO_InitStructure.GPIO_Alternate=GPIO_InputAlt1;	56	GPIO_InitStructure.GPIO_Alternate=GPIO_InputAlt1;
57	GPIO_Init(GPIO5,&GPIO_InitStructure);	57	GPIO_Init(GPIO5,&GPIO_InitStructure);
58	// P5.1 CAN_TX	58	// P5.1 CAN_TX
59	GPIO_StructInit(&GPIO_InitStructure);	59	GPIO_StructInit(&GPIO_InitStructure);
60	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_1;	60	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_1;
61	GPIO_InitStructure.GPIO_Direction=GPIO_PinOutput;	61	GPIO_InitStructure.GPIO_Direction=GPIO_PinOutput;
62	GPIO_InitStructure.GPIO_Type=GPIO_Type_PushPull;	62	GPIO_InitStructure.GPIO_Type=GPIO_Type_PushPull;
63	GPIO_InitStructure.GPIO_Alternate=GPIO_OutputAlt2;	63	GPIO_InitStructure.GPIO_Alternate=GPIO_OutputAlt2;
64	GPIO_Init(GPIO5,&GPIO_InitStructure);	64	GPIO_Init(GPIO5,&GPIO_InitStructure);
65	}	65	}
66		66
67		67
68		68
69	/*******************************************************************************	69	/*******************************************************************************
70	* Function Name : CAN_IRQHandler	70	* Function Name : CAN_IRQHandler
71	* Description : This function handles the CAN interrupt request	71	* Description : This function handles the CAN interrupt request
72	*******************************************************************************/	72	*******************************************************************************/
73	void CAN_IRQHandler(void)	73	void CAN_IRQHandler(void)
74	{	74	{
75	u32 msgobj = 0;	75	u32 msgobj = 0;
76	if(CAN->IDR == 0x8000) /* status interrupt */	76	if(CAN->IDR == 0x8000) /* status interrupt */
77	{	77	{
78	(void)CAN->SR; /* read the status register to clear*/	78	(void)CAN->SR; /* read the status register to clear*/
79	}	79	}
80	else if(CAN->IDR >= 1 && CAN->IDR <= 32)	80	else if(CAN->IDR >= 1 && CAN->IDR <= 32)
81	{	81	{
82	/* get the message object number that caused the interrupt to occur */	82	/* get the message object number that caused the interrupt to occur */
83	switch(msgobj = CAN->IDR - 1)	83	switch(msgobj = CAN->IDR - 1)
84	{	84	{
85	case 0 /* CAN_TX_MSGOBJ */:	85	case 0 /* CAN_TX_MSGOBJ */:
86	CAN_ReleaseTxMessage(msgobj);	86	CAN_ReleaseTxMessage(msgobj);
87	break;	87	break;
88		88
89	case 1 /* CAN_RX_MSGOBJ */:	89	case 1 /* CAN_RX_MSGOBJ */:
90	CAN_ReceiveMessage(msgobj, FALSE, &RxCanMsg);	90	CAN_ReceiveMessage(msgobj, FALSE, &RxCanMsg);
91	CAN_ReleaseRxMessage(msgobj);	91	CAN_ReleaseRxMessage(msgobj);
92		92
93	if(RxCanMsg.Id >= CAN_IdRx && RxCanMsg.Id < CAN_IdRx + MAX_CAN_MSG)	93	if(RxCanMsg.Id >= CAN_IdRx && RxCanMsg.Id < CAN_IdRx + MAX_CAN_MSG)
94	{	94	{
95	memcpy(&CanRxMessage[RxCanMsg.Id - CAN_IdRx], &RxCanMsg,sizeof(RxCanMsg));	95	memcpy(&CanRxMessage[RxCanMsg.Id - CAN_IdRx], &RxCanMsg,sizeof(RxCanMsg));
96	}	96	}
97	if(RxCanMsg.Id == CAN_IdRx + MAX_CAN_MSG - 1)	97	if(RxCanMsg.Id == CAN_IdRx + MAX_CAN_MSG - 1)
98	{	98	{
99	AllMsgsReceived = 1;	99	AllMsgsReceived = 1;
100	}	100	}
101	// DebugOut.Analog[] = RxCanMsg.Id;	101	// DebugOut.Analog[] = RxCanMsg.Id;
102	break;	102	break;
103		103
104	default:	104	default:
105	CAN_ReleaseMessage(msgobj);	105	CAN_ReleaseMessage(msgobj);
106	break;	106	break;
107	}	107	}
108	}	108	}
109		109
110	/write any value to VIC0 VAR/	110	/write any value to VIC0 VAR/
111	VIC0->VAR = 0xFF;	111	VIC0->VAR = 0xFF;
112		112
113	}	113	}
114		114
115	void CanSend(void)	115	void CanSend(void)
116	{	116	{
117	static u32 index = 1;	117	static u32 index = 1;
118		118
119	if(CAN_SendMessage(CAN_TX_MSGOBJ, (canmsg*) &CanTxMessage[index]) == SUCCESS)	119	if(CAN_SendMessage(CAN_TX_MSGOBJ, (canmsg*) &CanTxMessage[index]) == SUCCESS)
120	{	120	{
121	if(++index >= MAX_CAN_MSG)	121	if(++index >= MAX_CAN_MSG)
122	{	122	{
123	u32 i;	123	u32 i;
124	index = 0;	124	index = 0;
125	CanTxMessage[CAN_ID_STATUS].D.Byte[0] = ErrorCode;	125	CanTxMessage[CAN_ID_STATUS].D.Byte[0] = ErrorCode;
126		126
127	CanTxMessage[CAN_ID_FS_LON].D.sLong = GPS_FailsafePosition.Longitude;	127	CanTxMessage[CAN_ID_FS_LON].D.sLong[0] = GPS_FailsafePosition.Longitude;
128	CanTxMessage[CAN_ID_FS_LAT].D.sLong = GPS_FailsafePosition.Latitude;	128	CanTxMessage[CAN_ID_FS_LAT].D.sLong[0] = GPS_FailsafePosition.Latitude;
129		129
130	CanTxMessage[CAN_ID_STATUS].D.Byte[0] = ErrorCode;	130	CanTxMessage[CAN_ID_STATUS].D.Byte[0] = ErrorCode;
131	CanTxMessage[CAN_ID_STATUS].D.Byte[1] = FC.StatusFlags;	131	CanTxMessage[CAN_ID_STATUS].D.Byte[1] = FC.StatusFlags;
132	CanTxMessage[CAN_ID_STATUS].D.Byte[2] = FC.StatusFlags2;	132	CanTxMessage[CAN_ID_STATUS].D.Byte[2] = FC.StatusFlags2;
133	CanTxMessage[CAN_ID_STATUS].D.Byte[3] = FC.StatusFlags3;	133	CanTxMessage[CAN_ID_STATUS].D.Byte[3] = FC.StatusFlags3;
134	CanTxMessage[CAN_ID_STATUS].D.Byte[4] = NC_To_FC_Flags;	134	CanTxMessage[CAN_ID_STATUS].D.Byte[4] = NC_To_FC_Flags;
135	CanTxMessage[CAN_ID_STATUS].D.Byte[5] = EarthMagneticField/5; // in %	135	CanTxMessage[CAN_ID_STATUS].D.Byte[5] = EarthMagneticField/5; // in %
136	CanTxMessage[CAN_ID_STATUS].D.Int[3] = GyroCompassCorrected;	136	CanTxMessage[CAN_ID_STATUS].D.Int[3] = GyroCompassCorrected;
137		137
138	for(i=0; i<8;i++)	138	for(i=0; i<8;i++)
139	{	139	{
140	CanTxMessage[CAN_ID_TEXT1].D.Byte[i] = ErrorMSG[i];	140	CanTxMessage[CAN_ID_TEXT1].D.Byte[i] = ErrorMSG[i];
141	CanTxMessage[CAN_ID_TEXT2].D.Byte[i] = ErrorMSG[i + 8];	141	CanTxMessage[CAN_ID_TEXT2].D.Byte[i] = ErrorMSG[i + 8];
142	CanTxMessage[CAN_ID_TEXT3].D.Byte[i] = ErrorMSG[i + 16];	142	CanTxMessage[CAN_ID_TEXT3].D.Byte[i] = ErrorMSG[i + 16];
143	}	143	}
144	}	144	}
145	}	145	}
146	}	146	}
147		147
148	void CanReceive(void)	148	void CanReceive(void)
149	{	149	{
150		150
151	}	151	}
152		152
153		153
154	void CanbusInit(void)	154	void CanbusInit(void)
155	{	155	{
156	UART1_PutString("\r\n Canbus init...");	156	UART1_PutString("\r\n Canbus init...");
157	CAN_IO_Init();	157	CAN_IO_Init();
158	SCU_APBPeriphClockConfig(__CAN, ENABLE);	158	SCU_APBPeriphClockConfig(__CAN, ENABLE);
159	SCU_APBPeriphReset(__CAN, DISABLE);	159	SCU_APBPeriphReset(__CAN, DISABLE);
160		160
161	VIC_Config(CAN_ITLine, VIC_IRQ, Priority_1);	161	VIC_Config(CAN_ITLine, VIC_IRQ, Priority_1);
162	CAN_InitStructure.CAN_ConfigParameters=CAN_CR_IE;	162	CAN_InitStructure.CAN_ConfigParameters=CAN_CR_IE;
163	CAN_InitStructure.CAN_Bitrate = CAN_BITRATE_1M;	163	CAN_InitStructure.CAN_Bitrate = CAN_BITRATE_1M;
164	CAN_Init(&CAN_InitStructure);	164	CAN_Init(&CAN_InitStructure);
165	VIC_ITCmd(CAN_ITLine, ENABLE);	165	VIC_ITCmd(CAN_ITLine, ENABLE);
166		166
167	CAN_SetUnusedAllMsgObj();	167	CAN_SetUnusedAllMsgObj();
168	CAN_SetTxMsgObj(CAN_TX_MSGOBJ, CAN_STD_ID, DISABLE);	168	CAN_SetTxMsgObj(CAN_TX_MSGOBJ, CAN_STD_ID, DISABLE);
169	CAN_SetRxMsgObj(CAN_RX_MSGOBJ, CAN_STD_ID, 0, CAN_LAST_STD_ID, TRUE);	169	CAN_SetRxMsgObj(CAN_RX_MSGOBJ, CAN_STD_ID, 0, CAN_LAST_STD_ID, TRUE);
170		170
171	u32 i;	171	u32 i;
172		172
173	if(IamMaster == SLAVE)	173	if(IamMaster == SLAVE)
174	{	174	{
175	CAN_IdRx = CAN_MSG_ADR_MA;	175	CAN_IdRx = CAN_MSG_ADR_MA;
176	CAN_IdTx = CAN_MSG_ADR_SL;	176	CAN_IdTx = CAN_MSG_ADR_SL;
177	}	177	}
178	else	178	else
179	{	179	{
180	CAN_IdRx = CAN_MSG_ADR_SL;	180	CAN_IdRx = CAN_MSG_ADR_SL;
181	CAN_IdTx = CAN_MSG_ADR_MA;	181	CAN_IdTx = CAN_MSG_ADR_MA;
182	}	182	}
183		183
184	for(i=0; i< MAX_CAN_MSG;i++)	184	for(i=0; i< MAX_CAN_MSG;i++)
185	{	185	{
186	// clear TX Buffer	186	// clear TX Buffer
187	CanTxMessage[i].IdType = CAN_STD_ID;	187	CanTxMessage[i].IdType = CAN_STD_ID;
188	CanTxMessage[i].Id = i + CAN_IdTx;	188	CanTxMessage[i].Id = i + CAN_IdTx;
189	CanTxMessage[i].Length = 8;	189	CanTxMessage[i].Length = 8;
190	CanTxMessage[i].D.Long = 0;	190	CanTxMessage[i].D.Long[0] = 0;
191		191
192	// clear receiving Buffer	192	// clear receiving Buffer
193	CanRxMessage[i].Id = 0;	193	CanRxMessage[i].Id = 0;
194	CanRxMessage[i].D.Long = 0;	194	CanRxMessage[i].D.Long[0] = 0;
195	}	195	}
196		196
197	CanTxMessage[CAN_ID_VERSION].D.Byte[0] = 0;	197	CanTxMessage[CAN_ID_VERSION].D.Byte[0] = 0;
198	CanTxMessage[CAN_ID_VERSION].D.Byte[1] = Parameter.ActiveSetting;	198	CanTxMessage[CAN_ID_VERSION].D.Byte[1] = Parameter.ActiveSetting;
199	CanTxMessage[CAN_ID_VERSION].D.Byte[2] = GPS_Version/1000;	199	CanTxMessage[CAN_ID_VERSION].D.Byte[2] = GPS_Version/1000;
200	CanTxMessage[CAN_ID_VERSION].D.Byte[3] = UART_VersionInfo.HWMajor;	200	CanTxMessage[CAN_ID_VERSION].D.Byte[3] = UART_VersionInfo.HWMajor;
201	CanTxMessage[CAN_ID_VERSION].D.Byte[4] = CAN_SLAVE_COMPATIBLE;	201	CanTxMessage[CAN_ID_VERSION].D.Byte[4] = CAN_SLAVE_COMPATIBLE;
202	CanTxMessage[CAN_ID_VERSION].D.Byte[5] = VERSION_PATCH;	202	CanTxMessage[CAN_ID_VERSION].D.Byte[5] = VERSION_PATCH;
203	CanTxMessage[CAN_ID_VERSION].D.Byte[6] = VERSION_MINOR;	203	CanTxMessage[CAN_ID_VERSION].D.Byte[6] = VERSION_MINOR;
204	CanTxMessage[CAN_ID_VERSION].D.Byte[7] = VERSION_MAJOR;	204	CanTxMessage[CAN_ID_VERSION].D.Byte[7] = VERSION_MAJOR;
205		205
206	UART1_PutString("ok");	206	UART1_PutString("ok");
207	}	207	}
208		208
209	void ProcessCanBus(void)	209	void ProcessCanBus(void)
210	{	210	{
211	u32 errorcnt = 0;	211	u32 errorcnt = 0;
212		212
213	CanSend();	213	CanSend();
214	CanReceive();	214	CanReceive();
215		215
216	errorcnt = CAN_GetTransmitErrorCounter();	216	errorcnt = CAN_GetTransmitErrorCounter();
217	//if(errorcnt > 200) CanbusInit();	217	//if(errorcnt > 200) CanbusInit();
218		218
219	if(CanbusTimeOut < 3)	219	if(CanbusTimeOut < 3)
220	{	220	{
221	if(CanbusTimeOut == 1) Partner.ErrorCode = 39; // ERR: Canbus	221	if(CanbusTimeOut == 1) Partner.ErrorCode = 39; // ERR: Canbus
222	Partner.StatusFlags = 0;	222	Partner.StatusFlags = 0;
223	Partner.StatusFlags2 = 0;	223	Partner.StatusFlags2 = 0;
224	Partner.StatusFlags3 = 0;	224	Partner.StatusFlags3 = 0;
225	Partner.NC_To_FC_Flags = 0;	225	Partner.NC_To_FC_Flags = 0;
226	Partner.MagnetField = 0;	226	Partner.MagnetField = 0;
227	Partner.GyroCompassCorrected = -1;	227	Partner.GyroCompassCorrected = -1;
228	sprintf(PartnerErrorMSG," --- ");	228	sprintf(PartnerErrorMSG," --- ");
229	}	229	}
230		230
231	if(CanRxMessage[CAN_ID_VERSION].D.Byte[6] == 13) // dann ist der Testdummy angeschlossen -> nur zum Testen von EXT2	231	if(CanRxMessage[CAN_ID_VERSION].D.Byte[6] == 13) // dann ist der Testdummy angeschlossen -> nur zum Testen von EXT2
232	{	232	{
233	if((PartnerErrorMSG[17] + PartnerErrorMSG[18]) & 1) EXT2_ON;	233	if((PartnerErrorMSG[17] + PartnerErrorMSG[18]) & 1) EXT2_ON;
234	else EXT2_OFF;	234	else EXT2_OFF;
235	}	235	}
236		236
237	if(AllMsgsReceived)	237	if(AllMsgsReceived)
238	{	238	{
239	u32 i;	239	u32 i;
240	AllMsgsReceived = 0;	240	AllMsgsReceived = 0;
241	CanbusTimeOut = 1000;	241	CanbusTimeOut = 1000;
242	for(i=0; i<8;i++)	242	for(i=0; i<8;i++)
243	{	243	{
244	PartnerErrorMSG[i] = CanRxMessage[CAN_ID_TEXT1].D.Byte[i];	244	PartnerErrorMSG[i] = CanRxMessage[CAN_ID_TEXT1].D.Byte[i];
245	PartnerErrorMSG[i+8] = CanRxMessage[CAN_ID_TEXT2].D.Byte[i];	245	PartnerErrorMSG[i+8] = CanRxMessage[CAN_ID_TEXT2].D.Byte[i];
246	PartnerErrorMSG[i+16] = CanRxMessage[CAN_ID_TEXT3].D.Byte[i];	246	PartnerErrorMSG[i+16] = CanRxMessage[CAN_ID_TEXT3].D.Byte[i];
247	}	247	}
248	Partner.ErrorCode = CanRxMessage[CAN_ID_STATUS].D.Byte[0];	248	Partner.ErrorCode = CanRxMessage[CAN_ID_STATUS].D.Byte[0];
249	Partner.StatusFlags = CanRxMessage[CAN_ID_STATUS].D.Byte[1];	249	Partner.StatusFlags = CanRxMessage[CAN_ID_STATUS].D.Byte[1];
250	Partner.StatusFlags2 = CanRxMessage[CAN_ID_STATUS].D.Byte[2];	250	Partner.StatusFlags2 = CanRxMessage[CAN_ID_STATUS].D.Byte[2];
251	Partner.StatusFlags3 = CanRxMessage[CAN_ID_STATUS].D.Byte[3];	251	Partner.StatusFlags3 = CanRxMessage[CAN_ID_STATUS].D.Byte[3];
252	Partner.NC_To_FC_Flags = CanRxMessage[CAN_ID_STATUS].D.Byte[4];	252	Partner.NC_To_FC_Flags = CanRxMessage[CAN_ID_STATUS].D.Byte[4];
253	Partner.MagnetField = CanRxMessage[CAN_ID_STATUS].D.Byte[5];	253	Partner.MagnetField = CanRxMessage[CAN_ID_STATUS].D.Byte[5];
254	Partner.GyroCompassCorrected = CanRxMessage[CAN_ID_STATUS].D.Int[3];	254	Partner.GyroCompassCorrected = CanRxMessage[CAN_ID_STATUS].D.Int[3];
255		255
256	CanTxMessage[CAN_ID_VERSION].D.Byte[1] = Parameter.ActiveSetting;	256	CanTxMessage[CAN_ID_VERSION].D.Byte[1] = Parameter.ActiveSetting;
257		257
258	if(IamMaster == SLAVE)	258	if(IamMaster == SLAVE)
259	{	259	{
260	GPS_FailsafePosition.Longitude = CanRxMessage[CAN_ID_FS_LON].D.sLong;	260	GPS_FailsafePosition.Longitude = CanRxMessage[CAN_ID_FS_LON].D.sLong[0];
261	GPS_FailsafePosition.Latitude = CanRxMessage[CAN_ID_FS_LAT].D.sLong;	261	GPS_FailsafePosition.Latitude = CanRxMessage[CAN_ID_FS_LAT].D.sLong[0];
262	}	262	}
263	}	263	}
264	}	264	}
265		265
266		266
267		267
268		268
269		269
270		270

Subversion Repositories NaviCtrl

(root)/tags/V2.16a/canbus.c @ 897 - Rev 721 → 766