Subversion Repositories NaviCtrl

Compare Revisions

Ignore whitespace Rev 695 → Rev 696

/trunk/canbus.c
1,3 → 1,4
#include <string.h>
#include "91x_lib.h"
#include "91x_can.h"
#include "timer1.h"
5,10 → 6,11
#include "canbus.h"
#include "main.h"
#include "uart1.h"
#include "GPS.h"
 
canmsg CanMsg;
canmsg RxCanMsg;
volatile u32 frame_received_flag;
volatile u32 AllMsgsReceived;
 
GPIO_InitTypeDef GPIO_InitStructure;
CAN_InitTypeDef CAN_InitStructure;
22,7 → 24,7
}VIC_Priority;
 
/* buffer for receive messages */
canmsg RxCanMsg;
canmsg RxCanTxMsg;
 
/* used message object numbers */
enum {
30,13 → 32,19
CAN_RX_MSGOBJ = 1
};
 
/* array of pre-defined transmit messages */
canmsg TxCanMsg[3] = {
{ CAN_STD_ID, 0x123, 4, { 0x01, 0x02, 0x04, 0x08 } },
{ CAN_STD_ID, 0x321, 2, { 0xAA, 0x55, 0xAA, 0x55 } },
{ CAN_EXT_ID, 0x12345678, 8, { 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17 } }
};
#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
79,9 → 87,17
 
case 1 /* CAN_RX_MSGOBJ */:
CAN_ReceiveMessage(msgobj, FALSE, &RxCanMsg);
CAN_ReleaseRxMessage(msgobj);
frame_received_flag = 1;
DebugOut.Analog[19]++;
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:
97,13 → 113,18
 
void CanSend(void)
{
// 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);
//CAN_UpdateMsgObj(CAN_TX_MSGOBJ, &TxCanMsg[1]);
TxCanMsg[1].Data[0] = DebugOut.Analog[24] / 256;
TxCanMsg[1].Data[1] = DebugOut.Analog[24] % 256;
CAN_SendMessage(CAN_TX_MSGOBJ, &TxCanMsg[1]);
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)
129,6 → 150,20
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");
}
 
141,12 → 176,21
 
//DebugOut.Analog[16] = CAN->SR ;
 
if(frame_received_flag)
if(AllMsgsReceived)
{
frame_received_flag = 0;
DebugOut.Analog[16] = RxCanMsg.Data[0] * 256 + RxCanMsg.Data[1];
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;
}
}
 
}
 
 
/trunk/canbus.h
6,4 → 6,24
extern canmsg RxCanMsg;
extern volatile u32 frame_received_flag;
 
 
typedef struct
{
u32 IdType;
u32 Id;
u32 Length; // data length
union
{
u8 Byte[8];
s8 sByte[8];
u16 Int[2];
s16 sInt[2];
u32 Long;
s32 sLong;
float Float;
} __attribute__((packed)) D;
} /*__attribute__((packed))*/ CanMessage_t;
 
//extern CanMessage_t CanMessage;
 
#endif