/*********************************************************************//**
* @brief c_entry: Main CAN program body
* @param[in] none
* @return none
**********************************************************************/
void c_entry(void)
{
/* Initialize debug via UART0
* – 115200bps
* – 8 data bit
* – No parity
* – 1 stop bit
* – No flow control
*/
debug_frmwrk_init();
print_menu();
/* Initialize CAN1 peripheral
* Note: Self-test mode doesn't require pin selection
*/
CAN_Init(_USING_CAN_NO, 125000);
//Enable self-test mode
CAN_ModeConfig(_USING_CAN_NO, CAN_SELFTEST_MODE, ENABLE);
//Enable Interrupt
CAN_IRQCmd(_USING_CAN_NO, CANINT_RIE, ENABLE);
CAN_IRQCmd(_USING_CAN_NO, CANINT_TIE1, ENABLE);
//Enable CAN Interrupt
NVIC_EnableIRQ(CAN_IRQn);
CAN_SetAFMode(CAN_ACC_BP);
CAN_InitMessage();
_DBG_("Transmitted buffer:");
PrintMessage(&TXMsg);
/** To test Bypass Mode: we send infinite messages to CAN2 and check
* receive process via COM1
*/
CAN_SendMsg(_USING_CAN_NO, &TXMsg);
#if (_USING_CAN_NO == CAN_1)
LPC_CAN1->CMR |=(1<<4); //Self Reception Request
#else
LPC_CAN2->CMR |=(1<<4);
#endif
while (1);
}
/** Configures the board hardware and chip peripherals for the demo's functionality. */
void SetupHardware(void)
{
/* Disable watchdog if enabled by bootloader/fuses */
MCUSR &= ~(1 << WDRF);
wdt_disable();
/* Disable clock division */
clock_prescale_set(clock_div_1);
/* Hardware Initialization */
Joystick_Init();
LEDs_Init();
USB_Init();
CAN_Init();
}
int main()
{
int i=0;
int err=0;
signal(SIGTERM, signal_handler);
signal(SIGINT, signal_handler);
mlockall(MCL_CURRENT | MCL_FUTURE);
can_handle = CAN_Open(HW_PCI, 1);
CAN_Init(can_handle, CAN_BAUD_1M, CAN_INIT_TYPE_EX);
printf("Status = %i\n", CAN_Status(can_handle));
err=rt_task_create(&test_task, "test", 0, 99, T_JOINABLE);
if (err) {
printf("receivetest: Failed to create rt task, code %d\n",errno);
return err;
}
rt_task_start(&test_task, test, NULL);
if (err) {
printf("receivetest: Failed to start rt task, code %d\n",errno);
return errno;
}
rt_task_join(&test_task);
for (i = 0; i < 5; i++)
{
printf(
"Frame = %08lx %02x %02x %02x %02x %02x %02x %02x %02x, Time diff = %llu ns\n",
(unsigned long) can_msg[i].Msg.ID,
can_msg[i].Msg.DATA[0],
can_msg[i].Msg.DATA[1],
can_msg[i].Msg.DATA[2],
can_msg[i].Msg.DATA[3],
can_msg[i].Msg.DATA[4],
can_msg[i].Msg.DATA[5],
can_msg[i].Msg.DATA[6],
can_msg[i].Msg.DATA[7],
i == 0 ? 0 :
(can_msg[i].dwTime*(unsigned long long)1000+can_msg[i].wUsec)*1000-
(can_msg[i-1].dwTime*(unsigned long long)1000+can_msg[i-1].wUsec)*1000
);
}
CAN_Close(can_handle);
return 0;
}
void CAN_Com_LoopBack(void)
{
/* initialize the CAN at a standard bitrate, interrupts disabled */
CAN_InitStructure.CAN_ConfigParameters=0x0;
CAN_InitStructure.CAN_Bitrate=CAN_BITRATE_1M;
CAN_Init(&CAN_InitStructure);
/* switch into Loopback+Silent mode (self-test) */
CAN_EnterTestMode(CAN_TESTR_LBACK | CAN_TESTR_SILENT);
/* configure the message objects */
CAN_InvalidateAllMsgObj();
CAN_SetTxMsgObj(CAN_TX_MSGOBJ, CAN_STD_ID);
CAN_SetRxMsgObj(CAN_RX_MSGOBJ, CAN_STD_ID, 0, CAN_LAST_STD_ID, TRUE);
/* Send the pre-defined answer */
CAN_SendMessage(CAN_TX_MSGOBJ, &TxCanMsg[1]);
/* wait until end of transmission */
CAN_WaitEndOfTx();
/* wait for reception of a data frame */
while (!CAN_ReceiveMessage(CAN_RX_MSGOBJ, FALSE, &RxCanMsg))
{
/*Add Timer*/
}
/* Test Received Msg */
if((RxCanMsg.IdType == CAN_STD_ID)&&(RxCanMsg.Id == 0x321)&&(RxCanMsg.Dlc == 4)
&&(RxCanMsg.Data[0]==0xAA)&&(RxCanMsg.Data[1]==0x55)&&(RxCanMsg.Data[2]==0xAA)&&(RxCanMsg.Data[3]==0x55)){
/*Received Msg OK*/
LED_ON(LD2);
} else {
/*Received Msg KO*/
LED_ON(LD4);
}
/* release the message objects */
CAN_ReleaseTxMessage(CAN_TX_MSGOBJ);
CAN_ReleaseRxMessage(CAN_RX_MSGOBJ);
/* switch back into Normal mode */
CAN_LeaveTestMode();
}
void CAN_Initialise()
{
CAN_InitTypeDef CAN_InitStruct;
CAN_FilterInitTypeDef CAN_FilterInitStructure;
void GPIO_Initialise();
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1,ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN2,ENABLE);
/* CAN register init */
CAN_DeInit(CAN2);
/* CAN cell init */
CAN_InitStruct.CAN_TTCM = DISABLE;
CAN_InitStruct.CAN_ABOM = DISABLE;
CAN_InitStruct.CAN_AWUM = DISABLE;
CAN_InitStruct.CAN_NART = DISABLE;
CAN_InitStruct.CAN_RFLM = DISABLE;
CAN_InitStruct.CAN_TXFP = DISABLE;
CAN_InitStruct.CAN_Mode = CAN_Mode_Normal;
CAN_InitStruct.CAN_SJW = CAN_SJW_3tq;
//Bus length 3-5m.
/* CAN Baudrate = 500 KBps (CAN clocked at 42 MHz) */
CAN_InitStruct.CAN_BS1 = CAN_BS1_4tq;
CAN_InitStruct.CAN_BS2 = CAN_BS2_2tq;
CAN_InitStruct.CAN_Prescaler = (42000000 / 7) / 500000; //12
CAN_Init(CAN2, &CAN_InitStruct);
/* CAN filter init */
CAN_FilterInitStructure.CAN_FilterNumber = 0;
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 = 0;
CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;
CAN_FilterInit(&CAN_FilterInitStructure);
/* Enable FIFO 0 message pending Interrupt */
CAN_ITConfig(CAN2, CAN_IT_FMP0, ENABLE);
}
/*
* Configure the pins according to their intended default function
*/
int _roboveroConfig(uint8_t * args)
{
int i;
UART_CFG_Type UARTConfigStruct;
PWM_TIMERCFG_Type PWMCfgDat;
configAllPins();
/*
* Enable 7 analog inputs
*/
ADC_Init(LPC_ADC, 200000);
for (i = 0; i < 4; i++)
ADC_ChannelCmd(LPC_ADC, i, ENABLE);
for (i = 5; i < 8; i++)
ADC_ChannelCmd(LPC_ADC, i, ENABLE);
/*
* Configure I2C0 for IMU communications
*/
I2C_Init(LPC_I2C0, 100000);
I2C_Cmd(LPC_I2C0, ENABLE);
/*
* Initialize CAN bus
*/
CAN_Init(LPC_CAN1, 100000);
/*
* Initialize UART1
*/
UART_ConfigStructInit(&UARTConfigStruct);
UARTConfigStruct.Baud_rate = 115200;
UART_Init((LPC_UART_TypeDef*)LPC_UART1, &UARTConfigStruct);
UART_TxCmd((LPC_UART_TypeDef*)LPC_UART1, ENABLE);
/*
* Initialize PWM
*
* Peripheral clock is 30MHz. Prescale by 30 cycles for 1us resolution.
*/
PWMCfgDat.PrescaleOption = PWM_TIMER_PRESCALE_TICKVAL;
PWMCfgDat.PrescaleValue = 30;
PWM_Init(LPC_PWM1, PWM_MODE_TIMER, &PWMCfgDat);
return 0;
}
PcanPci::PcanPci(unsigned char port, unsigned short speed)
{
std::cout << "Connecting to PCAN PCI... ";
pcanHandle = CAN_Open(HW_PCI, port);
if (pcanHandle == NULL)
std::cout << "error!" << std::endl;
else if (!CAN_Init(pcanHandle, speed, CAN_INIT_TYPE_ST) == 0)
std::cout << "error!" << std::endl;
else if (!resetMsgFilter())
std::cout << "error!" << std::endl;
else
{
emptyReadQueue();
std::cout << "done!" << std::endl;
}
}
void _CAN1_Init()
{
CAN_InitTypeDef CAN_InitStructure;
CAN_FilterInitTypeDef CAN_FilterInitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
_CAN1_GPIO_Init();
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1,ENABLE);
CAN_InitStructure.CAN_TTCM=DISABLE;
CAN_InitStructure.CAN_ABOM=DISABLE;
CAN_InitStructure.CAN_AWUM=DISABLE;
CAN_InitStructure.CAN_NART=DISABLE;
CAN_InitStructure.CAN_RFLM=DISABLE;
CAN_InitStructure.CAN_TXFP=DISABLE;
//CAN_InitStructure.CAN_Mode=CAN_Mode_Normal;
CAN_InitStructure.CAN_Mode=CAN_Mode_LoopBack;
CAN_InitStructure.CAN_SJW=CAN_SJW_1tq;/*重新同步跳宽*/
CAN_InitStructure.CAN_BS1=CAN_BS1_4tq;/*时间段1*/
CAN_InitStructure.CAN_BS2=CAN_BS2_3tq;/*时间段2*/
CAN_InitStructure.CAN_Prescaler=45;/*波特率预分频数*/
CAN_Init(CAN1,&CAN_InitStructure);
//允许所有报文通过
CAN_FilterInitStructure.CAN_FilterNumber=0; //设置过滤器组0，范围为0~13
CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;//指定过滤器被设置为标识符屏蔽模式
CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;//给出过滤器位宽为32位
CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;
CAN_FilterInitStructure.CAN_FilterIdLow=0x0000;
CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;
CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;
CAN_FilterInitStructure.CAN_FilterFIFOAssignment=0;//为过滤器分配缓存 此处到//fifo 因为 CAN_FilterInitStructure.CAN_FilterNumber=0;
CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;
CAN_FilterInit(&CAN_FilterInitStructure);
CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);
NVIC_InitStructure.NVIC_IRQChannel=CAN1_RX1_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
}
bool CANPeakSysUSB::initCAN() {
int ret = CAN_ERR_OK;
bool bRet = true;
switch(m_iBaudrateVal)
{
case 0:
ret = CAN_Init(m_handle, CAN_BAUD_1M, CAN_INIT_TYPE_ST);
break;
case 2:
ret = CAN_Init(m_handle, CAN_BAUD_500K, CAN_INIT_TYPE_ST);
break;
case 4:
ret = CAN_Init(m_handle, CAN_BAUD_250K, CAN_INIT_TYPE_ST);
break;
case 6:
ret = CAN_Init(m_handle, CAN_BAUD_125K, CAN_INIT_TYPE_ST);
break;
case 9:
ret = CAN_Init(m_handle, CAN_BAUD_50K, CAN_INIT_TYPE_ST);
break;
case 11:
ret = CAN_Init(m_handle, CAN_BAUD_20K, CAN_INIT_TYPE_ST);
break;
case 13:
ret = CAN_Init(m_handle, CAN_BAUD_10K, CAN_INIT_TYPE_ST);
break;
}
if(ret)
{
std::cout << "CANPeakSysUSB::CANPeakSysUSB(), error in init" << std::endl;
m_bInitialized = false;
bRet = false;
}
else
{
std::cout << "CANPeakSysUSB::CanpeakSys(), init ok" << std::endl;
m_bInitialized = true;
bRet = true;
}
return bRet;
}
bool ros_for_can::initCAN() {
int ret = CAN_ERR_OK;
bool bRet = true;
switch(m_iBaudrateVal)
{
case CANITFBAUD_1M:
ret = CAN_Init(m_handle, CAN_BAUD_1M, CAN_INIT_TYPE_ST);
break;
case CANITFBAUD_500K:
ret = CAN_Init(m_handle, CAN_BAUD_500K, CAN_INIT_TYPE_ST);
break;
case CANITFBAUD_250K:
ret = CAN_Init(m_handle, CAN_BAUD_250K, CAN_INIT_TYPE_ST);
break;
case CANITFBAUD_125K:
ret = CAN_Init(m_handle, CAN_BAUD_125K, CAN_INIT_TYPE_ST);
break;
case CANITFBAUD_50K:
ret = CAN_Init(m_handle, CAN_BAUD_50K, CAN_INIT_TYPE_ST);
break;
case CANITFBAUD_20K:
ret = CAN_Init(m_handle, CAN_BAUD_20K, CAN_INIT_TYPE_ST);
break;
case CANITFBAUD_10K:
ret = CAN_Init(m_handle, CAN_BAUD_10K, CAN_INIT_TYPE_ST);
break;
}
if(ret)
{
std::cout << "ros_for_can::ros_for_can(), error in init" << std::endl;
m_bInitialized = false;
bRet = false;
}
else
{
std::cout << "ros_for_can::CanpeakSys(), init ok" << std::endl;
m_bInitialized = true;
bRet = true;
}
return bRet;
}
/**
* @brief Configures the CAN.
* @param None
* @retval : None
*/
void CAN_Config(void)
{
/* CAN register init */
CAN_DeInit(CAN1);
CAN_StructInit(&CAN_InitStructure);
/* CAN cell init */
CAN_InitStructure.CAN_TTCM = DISABLE;
CAN_InitStructure.CAN_ABOM = DISABLE;
CAN_InitStructure.CAN_AWUM = DISABLE;
CAN_InitStructure.CAN_NART = DISABLE;
CAN_InitStructure.CAN_RFLM = DISABLE;
CAN_InitStructure.CAN_TXFP = DISABLE;
CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;
CAN_InitStructure.CAN_SJW = CAN_SJW_1tq;
CAN_InitStructure.CAN_BS1 = CAN_BS1_10tq;
CAN_InitStructure.CAN_BS2 = CAN_BS2_7tq;
CAN_InitStructure.CAN_Prescaler = 2;
CAN_Init(CAN1, &CAN_InitStructure);
/* CAN filter init */
/* CAN filter init */
CAN_FilterInitStructure.CAN_FilterNumber=0;
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=0;
CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;
CAN_FilterInit(&CAN_FilterInitStructure);
/* transmit */
TxMessage.StdId = 0x321;
TxMessage.ExtId = 0x01;
TxMessage.RTR = CAN_RTR_DATA;
TxMessage.IDE = CAN_ID_STD;
TxMessage.DLC = 1;
}
/*
* 函数名：CAN_Mode_Config
* 描述 ：CAN的模式 配置
* 输入 ：无
* 输出 : 无
* 调用 ：内部调用
*/
static void CAN_Mode_Config(void)
{
CAN_InitTypeDef CAN_InitStructure;
/************************CAN通信参数设置**********************************/
/*CAN寄存器初始化*/
CAN_DeInit(CAN1);
CAN_StructInit(&CAN_InitStructure);
/*CAN单元初始化*/
CAN_InitStructure.CAN_TTCM=DISABLE; //MCR-TTCM 时间触发通信模式使能
CAN_InitStructure.CAN_ABOM=DISABLE; //MCR-ABOM 自动离线管理
CAN_InitStructure.CAN_AWUM=DISABLE; //MCR-AWUM 自动唤醒模式
CAN_InitStructure.CAN_NART=DISABLE; //MCR-NART 禁止报文自动重传 DISABLE-自动重传
CAN_InitStructure.CAN_RFLM=DISABLE; //MCR-RFLM 接收FIFO 锁定模式 DISABLE-溢出时新报文会覆盖原有报文
CAN_InitStructure.CAN_TXFP=DISABLE; //MCR-TXFP 发送FIFO优先级 DISABLE-优先级取决于报文标示符
CAN_InitStructure.CAN_Mode = CAN_Mode_Normal; //正常发送模式
CAN_InitStructure.CAN_SJW=CAN_SJW_2tq; //BTR-SJW 重新同步跳跃宽度 2个时间单元
CAN_InitStructure.CAN_BS1=CAN_BS1_6tq; //BTR-TS1 时间段1 占用了6个时间单元
CAN_InitStructure.CAN_BS2=CAN_BS2_3tq; //BTR-TS1 时间段2 占用了3个时间单元
CAN_InitStructure.CAN_Prescaler =4; ////BTR-BRP 波特率分频器 定义了时间单元的时间长度 36/(1+6+3)/4=0.8Mbps
CAN_Init(CAN1, &CAN_InitStructure);
}
void CAN1_Configuration(void)
{
CAN_InitTypeDef CAN_InitStructure;
CAN_FilterInitTypeDef CAN_FilterInitStructure;
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1,ENABLE); //注意，挂在APB1
/************************模式与波特率设置*************/
CAN_DeInit(CAN1);
CAN_StructInit(&CAN_InitStructure);
CAN_InitStructure.CAN_TTCM=DISABLE;
CAN_InitStructure.CAN_ABOM=DISABLE;
CAN_InitStructure.CAN_AWUM=DISABLE;
CAN_InitStructure.CAN_NART=DISABLE;
CAN_InitStructure.CAN_RFLM=DISABLE;
CAN_InitStructure.CAN_TXFP=DISABLE;
CAN_InitStructure.CAN_Mode = CAN_Mode_Normal; //CAN_Mode_LoopBack：回环模式，CAN_Mode_Normal:正常模式
CAN_InitStructure.CAN_SJW = CAN_SJW_1tq;
CAN_InitStructure.CAN_BS1 = CAN_BS1_5tq;
CAN_InitStructure.CAN_BS2 = CAN_BS2_3tq;
CAN_InitStructure.CAN_Prescaler = 4; //100K通信速度
CAN_Init(CAN1,&CAN_InitStructure);
/***********************过滤器设置********************/
CAN_FilterInitStructure.CAN_FilterNumber = 0; //0号过滤器
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; //传入FIFO0
CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;
CAN_FilterInit(&CAN_FilterInitStructure);
CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE); //开启接收中断
}
/****************************************************************************
* Name: arm_caninit(void)
****************************************************************************/
int arm_caninit(){
/* Initialization of the CAN hardware is performed by logic external to
* this test.
*/
const char *szDeviceNode = DEFAULT_NODE;
errno = 0;
/* Open the CAN device for reading */
// open the CAN port
// please use what is appropriate
// HW_DONGLE_SJA
// HW_DONGLE_SJA_EPP
// HW_ISA_SJA
// HW_PCI
h = LINUX_CAN_Open(szDeviceNode, O_RDWR);
if (!h)
{
errno = nGetLastError();
perror("bitratetest: CAN_Open()");
return 0;
}
/*set the bitrate*/
errno = CAN_Init(h,CAN_BAUD_1M,CAN_INIT_TYPE_ST);
if(errno)
{
perror("set can speed error");
CAN_Close(h);
return 0;
}
/* Now loop the appropriate number of times, performing one loopback test
* on each pass.
*/
printf("can init is ok!\n");
//return 1 is ok;
return 1;
}
CAN_HANDLE canOpen_driver(s_BOARD *board)
{
HANDLE fd0 = NULL;
char busname[64];
char* pEnd;
int baudrate;
if(strtol(board->busname, &pEnd,0) >= 0)
{
sprintf(busname,"/dev/pcan%s",board->busname);
fd0 = LINUX_CAN_Open(busname, O_RDWR);
}
if(fd0 && (baudrate = TranslateBaudeRate(board->baudrate)))
{
CAN_Init(fd0, baudrate, CAN_INIT_TYPE_ST);
}else{
fprintf(stderr, "canOpen_driver (Peak_Linux) : error opening %s\n", busname);
}
return (CAN_HANDLE)fd0;
}
static void CAN_Mode_Config(void)
{
CAN_InitTypeDef CAN_InitStructure;
/* CAN register init */
CAN_DeInit(CAN1);
CAN_StructInit(&CAN_InitStructure);
/* CAN cell init */
CAN_InitStructure.CAN_TTCM=DISABLE; // 时间触发通信禁止
CAN_InitStructure.CAN_ABOM=DISABLE; // 离线退出是在中断置位清0后退出
CAN_InitStructure.CAN_AWUM=DISABLE; // 自动唤醒模式：清零sleep
CAN_InitStructure.CAN_NART=DISABLE; // 自动重新传送豹纹，知道发送成功
CAN_InitStructure.CAN_RFLM=DISABLE; // FIFO没有锁定，新报文覆盖旧报文
CAN_InitStructure.CAN_TXFP=DISABLE; // 发送报文优先级确定：标志符
CAN_InitStructure.CAN_Mode=CAN_Mode_LoopBack; // 回环模式
CAN_InitStructure.CAN_SJW=CAN_SJW_1tq; // 1tq、BS1、BS2的值跟波特率有关
CAN_InitStructure.CAN_BS1=CAN_BS1_8tq;
CAN_InitStructure.CAN_BS2=CAN_BS2_7tq;
CAN_InitStructure.CAN_Prescaler=5; // 分频系数为5
CAN_Init(CAN1, &CAN_InitStructure); // 初始化CAN1
}
//----------------------------------------------------
int main(int argc, char *argv[])
{ int i,j=0,k=0,M=0, N=0;
printf("Creating Timer\n");
if(0>MSTimerCreate())
{ printf("Timer Creation Failed\n");
}
CAN_Init();
for(k=0;k<10;k++)
{ for(i=0;i<1000;i++)
{ for(j=0;j<94000;j++)
{ M=i+j;
}
}
printf("%d %d\n",k, mscount); //global to avoid function call
}
/*
while( M < 50)
{ N=CAN_Get();
if(!N)
{ ++M;
}
}
*/
printf("Destroying timer\n");
MSTimerDestroy();
printf("Destroying CAN\n");
CAN_Destroy();
return 0;
}
static void initCAN(CAN_TypeDef * CANx, uint32_t baud)
{
CAN_InitTypeDef CAN_InitStructure;
/* CAN cell init */
CAN_InitStructure.CAN_TTCM = DISABLE;
CAN_InitStructure.CAN_ABOM = ENABLE;
CAN_InitStructure.CAN_AWUM = DISABLE;
CAN_InitStructure.CAN_NART = DISABLE;
CAN_InitStructure.CAN_RFLM = DISABLE;
CAN_InitStructure.CAN_TXFP = DISABLE;
CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;
int baudIndex = -1;
/* Select baud rate up to requested rate, except for below min, where min is selected */
if (baud >= can_baud_rate[CAN_BAUD_COUNT - 1]) {
/* round down to peak rate if >= peak rate */
baudIndex = CAN_BAUD_COUNT - 1;
} else {
for (baudIndex = 0; baudIndex < CAN_BAUD_COUNT - 1; baudIndex++) {
if (baud < can_baud_rate[baudIndex + 1]) {
/* take current idx if next is too large */
break;
}
}
}
CAN_InitStructure.CAN_SJW = can_baud_sjw[baudIndex];
CAN_InitStructure.CAN_BS1 = can_baud_bs1[baudIndex];
CAN_InitStructure.CAN_BS2 = can_baud_bs2[baudIndex];
CAN_InitStructure.CAN_Prescaler = can_baud_pre[baudIndex];
CAN_Init(CANx, &CAN_InitStructure);
}
HANDLE initCAN(void)
{
const char *szDevNode = PCAN_DEVICE;
uint16_t wBTR0BTR1 = CAN_BAUD_RATE_REG_VAL;
HANDLE h;
h = LINUX_CAN_Open(szDevNode, O_RDWR);
if (!h)
{
printf("transmitest: can't open %s\n", szDevNode);
return NULL;
}
// init to a user defined bit rate
if (wBTR0BTR1)
{
errno = CAN_Init(h, wBTR0BTR1, CAN_INIT_TYPE_ST);
if (errno)
{
perror("transmitest: CAN_Init()");
return NULL;
}
}
return h;
}
void USB2CAN_set_speed(u8 speed,CAN_TIMINGS *CanTimings)
{
CAN_InitTypeDef CAN_Struct;
switch(speed)
{
case CAN_BAUD_10:
CAN_Struct.CAN_Bitrate=CAN_BITRATE_10K;
CAN_Struct.CAN_ConfigParameters = CAN_CR_IE ;
CAN_Init( &CAN_Struct );
break;
case CAN_BAUD_20:
CAN_Struct.CAN_Bitrate=CAN_BITRATE_20K;
CAN_Struct.CAN_ConfigParameters = CAN_CR_IE ;
CAN_Init( &CAN_Struct );
break;
case CAN_BAUD_50:
CAN_Struct.CAN_Bitrate=CAN_BITRATE_50K;
CAN_Struct.CAN_ConfigParameters = CAN_CR_IE ;
CAN_Init( &CAN_Struct );
break;
case CAN_BAUD_100:
CAN_Struct.CAN_Bitrate=CAN_BITRATE_100K;
CAN_Struct.CAN_ConfigParameters = CAN_CR_IE ;
CAN_Init( &CAN_Struct );
break;
case CAN_BAUD_125:
CAN_Struct.CAN_Bitrate=CAN_BITRATE_125K;
CAN_Struct.CAN_ConfigParameters = CAN_CR_IE ;
CAN_Init( &CAN_Struct );
break;
case CAN_BAUD_250:
CAN_Struct.CAN_Bitrate=CAN_BITRATE_250K;
CAN_Struct.CAN_ConfigParameters = CAN_CR_IE ;
CAN_Init( &CAN_Struct );
break;
case CAN_BAUD_500:
CAN_Struct.CAN_Bitrate=CAN_BITRATE_500K;
CAN_Struct.CAN_ConfigParameters = CAN_CR_IE ;
CAN_Init( &CAN_Struct );
break;
case CAN_BAUD_800:
CAN_Struct.CAN_Bitrate=CAN_BITRATE_800K;
CAN_Struct.CAN_ConfigParameters = CAN_CR_IE ;
CAN_Init( &CAN_Struct );
break;
case CAN_BAUD_1000:
CAN_Struct.CAN_Bitrate=CAN_BITRATE_1M;
CAN_Struct.CAN_ConfigParameters = CAN_CR_IE ;
CAN_Init( &CAN_Struct );
break;
case CAN_BAUD_MANUAL:
CAN_EnterInitMode(CAN_CR_CCE | CAN_CR_IE);
CAN_SetTiming(CanTimings->tseg1,CanTimings->tseg2,CanTimings->sjw,CanTimings->brp);
CAN_LeaveInitMode();
break;
default: // 125K
CAN_Struct.CAN_Bitrate=CAN_BITRATE_125K;
CAN_Struct.CAN_ConfigParameters = CAN_CR_IE ;
CAN_Init( &CAN_Struct );
break;
}
}
/*****************************************************************************
** Function name: main
**
** Descriptions: main routine for CAN module test
**
** parameters: None
** Returned value: int
**
*****************************************************************************/
int main( void )
{
/* SystemClockUpdate() updates the SystemFrequency variable */
SystemClockUpdate();
/* Please note, the bit timing is based on the setting of the
PCLK, if different PCLK is used, please read can.h carefully
and set your CAN bit timing accordingly. */
//CAN_Init( BITRATE100K24MHZ );
CAN_Init( BITRATE125K18MHZ );
#if CAN_WAKEUP
CAN_WakeupTest();
#endif
/* send one message from CAN1(TX) and verify received message on
CAN2(RX) if it's a match, both CAN TX and RX are working.
For more details on acceptance filter program, see Philips
appnote AN10438 and the zip file associated with this appnote. */
#if !ACCEPTANCE_FILTER_ENABLED
/* Initialize MsgBuf */
MsgBuf_TX1.Frame = 0x80080000; /* 29-bit, no RTR, DLC is 8 bytes */
MsgBuf_TX1.MsgID = 0x00012345; /* CAN ID */
MsgBuf_TX1.DataA = 0x3C3C3C3C;
MsgBuf_TX1.DataB = 0xC3C3C3C3;
MsgBuf_RX2.Frame = 0x0;
MsgBuf_RX2.MsgID = 0x0;
MsgBuf_RX2.DataA = 0x0;
MsgBuf_RX2.DataB = 0x0;
CAN_SetACCF( ACCF_BYPASS );
/* Test bypass */
while ( 1 )
{
/* Transmit initial message on CAN 1 */
while ( !(LPC_CAN1->GSR & (1 << 3)) );
if ( CAN1_SendMessage( &MsgBuf_TX1 ) == FALSE )
{
continue;
}
if ( CAN2RxDone == TRUE )
{
CAN2RxDone = FALSE;
if ( MsgBuf_RX2.Frame & (1 << 10) ) /* by pass mode */
{
MsgBuf_RX2.Frame &= ~(1 << 10 );
}
if ( ( MsgBuf_TX1.Frame != MsgBuf_RX2.Frame ) ||
( MsgBuf_TX1.MsgID != MsgBuf_RX2.MsgID ) ||
( MsgBuf_TX1.DataA != MsgBuf_RX2.DataA ) ||
( MsgBuf_TX1.DataB != MsgBuf_RX2.DataB ) )
{
while ( 1 );
}
/* Everything is correct, reset buffer */
MsgBuf_RX2.Frame = 0x0;
MsgBuf_RX2.MsgID = 0x0;
MsgBuf_RX2.DataA = 0x0;
MsgBuf_RX2.DataB = 0x0;
} /* Message on CAN 2 received */
}
#else
/* Test Acceptance Filter */
/* Even though the filter RAM is set for all type of identifiers,
the test module tests explicit standard identifier only */
MsgBuf_TX1.Frame = 0x00080000; /* 11-bit, no RTR, DLC is 8 bytes */
MsgBuf_TX1.MsgID = EXP_STD_ID; /* Explicit Standard ID */
MsgBuf_TX1.DataA = 0x55AA55AA;
MsgBuf_TX1.DataB = 0xAA55AA55;
MsgBuf_RX2.Frame = 0x0;
MsgBuf_RX2.MsgID = 0x0;
MsgBuf_RX2.DataA = 0x0;
MsgBuf_RX2.DataB = 0x0;
CAN_SetACCF( ACCF_ON );
while ( 1 )
{
/* Transmit initial message on CAN 1 */
while ( !(LPC_CAN1->GSR & (1 << 3)) );
if ( CAN1_SendMessage( &MsgBuf_TX1 ) == FALSE )
{
continue;
}
/* please note: FULLCAN identifier will NOT be received as it's not set
in the acceptance filter. */
if ( CAN2RxDone == TRUE )
{
CAN2RxDone = FALSE;
/* The frame field is not checked, as ID index varies based on the
entries set in the filter RAM. */
if ( ( MsgBuf_TX1.MsgID != MsgBuf_RX2.MsgID ) ||
( MsgBuf_TX1.DataA != MsgBuf_RX2.DataA ) ||
( MsgBuf_TX1.DataB != MsgBuf_RX2.DataB ) )
{
while ( 1 );
}
/* Everything is correct, reset buffer */
MsgBuf_RX2.Frame = 0x0;
MsgBuf_RX2.MsgID = 0x0;
MsgBuf_RX2.DataA = 0x0;
MsgBuf_RX2.DataB = 0x0;
} /* Message on CAN 2 received */
}
#endif
}
/*******************************************************************************
* Function Name : CAN_Initialize
* Description : Configures the CAN, transmit and receive using interrupt.
* Input : None
* Output : None
* Return : PASSED if the reception is well done, FAILED in other case
*******************************************************************************/
_io *Initialize_CAN(int loop)
{
CAN_InitTypeDef CAN_InitStructure;
CAN_FilterInitTypeDef CAN_FilterInitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_StructInit(&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource5, GPIO_AF_CAN2);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource13, GPIO_AF_CAN2);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE); // glej opis driverja, šmafu, treba inicializirat c
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN2, ENABLE);
CAN_StructInit(&CAN_InitStructure);
CAN_DeInit(__CAN__);
CAN_InitStructure.CAN_TTCM=DISABLE;
CAN_InitStructure.CAN_ABOM=ENABLE;
CAN_InitStructure.CAN_AWUM=DISABLE;
CAN_InitStructure.CAN_NART=ENABLE;
CAN_InitStructure.CAN_RFLM=DISABLE;
//... pomembn.. da ne zamesa mailboxov in jih oddaja po vrstnem redu vpisovanja... ni default !!!
CAN_InitStructure.CAN_TXFP=ENABLE;
if(loop)
CAN_InitStructure.CAN_Mode=CAN_Mode_LoopBack;
else
CAN_InitStructure.CAN_Mode=CAN_Mode_Normal;
CAN_InitStructure.CAN_SJW=CAN_SJW_4tq;
CAN_InitStructure.CAN_BS1=CAN_BS1_10tq;
CAN_InitStructure.CAN_BS2=CAN_BS2_4tq;
CAN_InitStructure.CAN_Prescaler=4;
CAN_Init(__CAN__,&CAN_InitStructure);
CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdList;
CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;
CAN_FilterInitStructure.CAN_FilterMaskIdLow=0;
CAN_FilterInitStructure.CAN_FilterIdLow=0;
CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;
CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;
// filtri za PFM in EC
CAN_FilterInitStructure.CAN_FilterIdHigh=_ID_SYS2PFM<<5;
CAN_FilterInitStructure.CAN_FilterMaskIdHigh=_ID_SYS2EC<<5;
CAN_FilterInitStructure.CAN_FilterNumber=__FILT_BASE__+0;
CAN_FilterInit(&CAN_FilterInitStructure);
CAN_FilterInitStructure.CAN_FilterIdHigh=_ID_SYS2PFMcom<<5;
CAN_FilterInitStructure.CAN_FilterMaskIdHigh=_ID_PFMcom2SYS<<5;
CAN_FilterInitStructure.CAN_FilterNumber=__FILT_BASE__+1;
CAN_FilterInit(&CAN_FilterInitStructure);
CAN_FilterInitStructure.CAN_FilterIdHigh=_ID_SYS_TRIGG<<5;
CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0<<5;
CAN_FilterInitStructure.CAN_FilterNumber=__FILT_BASE__+2;
CAN_FilterInit(&CAN_FilterInitStructure);
// filtri za IAP mode
// CAN_FilterInitStructure.CAN_FilterIdHigh=_ID_IAP_GO<<5;
// CAN_FilterInitStructure.CAN_FilterMaskIdHigh=_ID_IAP_ADDRESS<<5;
// CAN_FilterInitStructure.CAN_FilterNumber=__FILT_BASE__+3;
// CAN_FilterInit(&CAN_FilterInitStructure);
// CAN_FilterInitStructure.CAN_FilterIdHigh=_ID_IAP_DWORD<<5;
// CAN_FilterInitStructure.CAN_FilterMaskIdHigh=_ID_IAP_ERASE<<5;
// CAN_FilterInitStructure.CAN_FilterNumber=__FILT_BASE__+4;
// CAN_FilterInit(&CAN_FilterInitStructure);
// CAN_FilterInitStructure.CAN_FilterIdHigh=_ID_IAP_ACK<<5;
// CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0<<5;
// CAN_FilterInitStructure.CAN_FilterNumber=__FILT_BASE__+5;
// CAN_FilterInit(&CAN_FilterInitStructure);
CAN_ITConfig(__CAN__, CAN_IT_FMP0, ENABLE);
return(_io_init(100*sizeof(CanRxMsg),100*sizeof(CanTxMsg)));
}
void main()
{
u16 tmp;
u8 tmp8, tmp8_A;
static tCANMsg RxMsgBuff;
CLK_Init(CLK_HSE);
disableInterrupts();
GPIO_Init();
TIM4_Init();
// TIM2_Init();
TIM1_Init();
ADC_Init();
/* Configure CAN - Interface */
CAN_Init(); // init CAN - interface
enableInterrupts();
CAN_Start();
CAN_TxMsg1.Length = 4;
CAN_TxMsg1.Xtd = false;
CAN_TxMsg1.rtr = false;
CAN_TxMsg1.ID = 0x280;
CAN_TxMsg1.Data[0] =0 ;
CAN_TxMsg1.Data[1] =0;
//PWM_SetFrequency(1);
do {
if ( IsCAN_MSG1_Send()) {
tmp = ADC_GetValue(ADC_REV_CHANEL);
tmp = tmp *24;
if ( tmp < 100 ) {
OIL_PRESS = false;
} else {
OIL_PRESS = true;
}
CAN_TxMsg1.Data[3] =(u8)(tmp >> 8) ;
CAN_TxMsg1.Data[2] =(u8)(tmp & 0x00FF);
CAN_Write(&CAN_TxMsg1);
}
if ( IsSpeedAdjustTime()) {
tmp = ADC_GetValue(ADC_SPEED_CHANEL);
tmp = tmp * 10;
tmp = tmp/ 34;
PWM_SetFrequency(tmp);
// 1023 = 300 Hz
}
/* if( CAN_GetMsg(&RxMsgBuff)== RET_OK){
if (RxMsgBuff.Xtd ){ // EID
tmp8 = (u8)(RxMsgBuff.timeStamp >>3) & 0xE0U;
if (RxMsgBuff.rtr) tmp8 |= 0x10;
tmp8 |= (RxMsgBuff.Length & 0x0F);
tmp8_A = (RxMsgBuff.ID>>24) & 0x001f;
tmp8_A |= (RxMsgBuff.FilterID << 5);
USART_SendBytesMessage (CAN_MSG_EXT_1, tmp8,(u8)((RxMsgBuff.timeStamp) & 0x00FF), tmp8_A ,(RxMsgBuff.ID>>16) & 0x00ffU);
USART_SendBytesMessage (CAN_MSG_EXT_2, (RxMsgBuff.ID>>8) & 0x00ffU,RxMsgBuff.ID & 0x00ffU,RxMsgBuff.Data[0], RxMsgBuff.Data[1] );
if (RxMsgBuff.Length > 2)
USART_SendBytesMessage (CAN_MSG_EXT_3, RxMsgBuff.Data[2], RxMsgBuff.Data[3], RxMsgBuff.Data[4], RxMsgBuff.Data[5]);
if (RxMsgBuff.Length > 6 )
USART_SendBytesMessage (CAN_MSG_EXT_4, RxMsgBuff.Data[6], RxMsgBuff.Data[7],0,0);
}else{ // standard ID
tmp8 = (u8)(RxMsgBuff.timeStamp >>3) & 0xE0U;
if (RxMsgBuff.rtr) tmp8 |= 0x10;
tmp8 |= (RxMsgBuff.Length & 0x0F);
tmp8_A = (RxMsgBuff.ID>>8) & 0x007f;
tmp8_A |= (RxMsgBuff.FilterID << 3);
USART_SendBytesMessage (CAN_MSG_STD_1, tmp8,(u8)((RxMsgBuff.timeStamp) & 0x00FF), tmp8_A ,RxMsgBuff.ID & 0x00ff);
if (RxMsgBuff.Length > 0)
USART_SendBytesMessage (CAN_MSG_STD_2, RxMsgBuff.Data[0], RxMsgBuff.Data[1], RxMsgBuff.Data[2], RxMsgBuff.Data[3]);
if (RxMsgBuff.Length > 4 )
USART_SendBytesMessage (CAN_MSG_STD_3, RxMsgBuff.Data[4], RxMsgBuff.Data[5], RxMsgBuff.Data[6], RxMsgBuff.Data[7]);
}
}*/
/** LED Flashing **/
if (GetLedState()) {
LED_ON;
} else {
LED_OFF;
}
} while (1);
}
/**
* @brief Configures the CAN.
* @param None
* @retval None
*/
static void CAN_Config(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
/* CAN GPIOs configuration **************************************************/
/* Enable GPIO clock */
RCC_AHB1PeriphClockCmd(CAN_GPIO_CLK, ENABLE);
/* Connect CAN pins to AF9 */
GPIO_PinAFConfig(CAN_GPIO_PORT, CAN_RX_SOURCE, CAN_AF_PORT);
GPIO_PinAFConfig(CAN_GPIO_PORT, CAN_TX_SOURCE, CAN_AF_PORT);
/* Configure CAN RX and TX pins */
GPIO_InitStructure.GPIO_Pin = CAN_RX_PIN | CAN_TX_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(CAN_GPIO_PORT, &GPIO_InitStructure);
/* CAN configuration ********************************************************/
/* Enable CAN clock */
RCC_APB1PeriphClockCmd(CAN_CLK, ENABLE);
/* CAN register init */
CAN_DeInit(CANx);
/* CAN cell init */
CAN_InitStructure.CAN_TTCM = DISABLE;
CAN_InitStructure.CAN_ABOM = DISABLE;
CAN_InitStructure.CAN_AWUM = DISABLE;
CAN_InitStructure.CAN_NART = DISABLE;
CAN_InitStructure.CAN_RFLM = DISABLE;
CAN_InitStructure.CAN_TXFP = DISABLE;
CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;
CAN_InitStructure.CAN_SJW = CAN_SJW_1tq;
/* CAN Baudrate = 1 MBps (CAN clocked at 30 MHz) */
CAN_InitStructure.CAN_BS1 = CAN_BS1_6tq;
CAN_InitStructure.CAN_BS2 = CAN_BS2_8tq;
CAN_InitStructure.CAN_Prescaler = 2;
CAN_Init(CANx, &CAN_InitStructure);
/* CAN filter init */
CAN_FilterInitStructure.CAN_FilterNumber = 0;
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 = 0;
CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;
CAN_FilterInit(&CAN_FilterInitStructure);
/* Transmit Structure preparation */
TxMessage.StdId = 0x321;
TxMessage.ExtId = 0x01;
TxMessage.RTR = CAN_RTR_DATA;
TxMessage.IDE = CAN_ID_STD;
TxMessage.DLC = 1;
/* Enable FIFO 0 message pending Interrupt */
CAN_ITConfig(CANx, CAN_IT_FMP0, ENABLE);
}
void pcan_transmit::init(int argc, char **argv)
{
/*!
*\brief The init() function is based on the middle part of the main() function of the transmitest program.
*
* Compared to the transmitest program a lot of cases have been removed.
* Therefore, only the PCAN-USB adapter is, and standard messages are, supported.
*
* */
int nExtended = CAN_INIT_TYPE_ST;
int nType;
__u32 dwPort;
__u16 wIrq;
char *ptr;
__u16 wBTR0BTR1 = 0x011C;
// parameter wBTR0BTR1
// bitrate codes of BTR0/BTR1 registers
//#define CAN_BAUD_1M 0x0014 // 1 MBit/s
//#define CAN_BAUD_500K 0x001C // 500 kBit/s
//#define CAN_BAUD_250K 0x011C // 250 kBit/s
//#define CAN_BAUD_125K 0x031C // 125 kBit/s
//#define CAN_BAUD_100K 0x432F // 100 kBit/s
//#define CAN_BAUD_50K 0x472F // 50 kBit/s
//#define CAN_BAUD_20K 0x532F // 20 kBit/s
//#define CAN_BAUD_10K 0x672F // 10 kBit/s
//#define CAN_BAUD_5K 0x7F7F // 5 kBit/s
const char *szDevNode = DEFAULT_NODE;
bool bDevNodeGiven = false;
bool bTypeGiven = false;
char txt[VERSIONSTRING_LEN];
/* QApplication a(argc, argv);
QWidget *mainWindow=new QWidget;
mainWindow->setWindowTitle("Change the Data Value");
QSlider *slider= new QSlider(Qt::Horizontal);
QSpinBox *spinner= new QSpinBox;
slider->setRange(0,100);
spinner->setRange(0,100);
connect(ui->slider, SIGNAL(valueChanged(double)), SLOT(onSliderValueChanged(double)));
double slidValue= ui->Slider->value();
//string msg[]= "ID, LEN, ss";*/
// decode command line arguments
for (int i = 1; i < argc; i++)
{
char c;
ptr = argv[i];
while (*ptr == '-')
ptr++;
c = *ptr;
ptr++;
if (*ptr == '=')
ptr++;
switch(tolower(c))
{
case '?':
case 'h':
hlpMsg();
do_exit(errno, h);
break;
case 'f':
szDevNode = ptr;
bDevNodeGiven = true;
break;
case 'b':
wBTR0BTR1 = (__u16)strtoul(ptr, NULL, 16);
break;
default:
errno = EINVAL;
do_exit(errno, h);;
break;
}
}
/* open CAN port */
if ((bDevNodeGiven) || (!bDevNodeGiven && !bTypeGiven))
{
h = LINUX_CAN_Open(szDevNode, O_RDWR);
if (!h)
{
printf("pcan_transmit: can't open %s\n", szDevNode);
do_exit(errno, h);;
}
}
else {
// please use what is appropriate
// HW_DONGLE_SJA
// HW_DONGLE_SJA_EPP
// HW_ISA_SJA
// HW_PCI
h = CAN_Open(nType, dwPort, wIrq);
if (!h)
{
printf("pcan_transmit: can't open %s device.\n", getNameOfInterface(nType));
do_exit(errno, h);;
}
}
/* clear status */
CAN_Status(h);
// get version info
errno = CAN_VersionInfo(h, txt);
if (!errno)
printf("pcan_transmit: driver version = %s\n", txt);
else {
perror("pcan_transmit: CAN_VersionInfo()");
do_exit(errno, h);;
}
// init to a user defined bit rate
if (wBTR0BTR1)
{
errno = CAN_Init(h, wBTR0BTR1, nExtended);
if (errno)
{
perror("pcan_transmit: CAN_Init()");
do_exit(errno, h);;
}
}
}
int main()
{
pedal_node_state = pedal_state_neutral;
LCD_Start();
CAN_invertor_init();
ADC_SAR_Start();
ADC_SAR_StartConvert();
EEPROM_Start();
//isr_Start();
//Timer_Start();
CAN_timer_Start();
CAN_Init();
CAN_Start();
isr_start_StartEx(&isr_start_handler);
Start_Reset_Write(1); /* source of interrupt (reset) */
isr_start_ClearPending();
isr_neutral_StartEx(&isr_neutral_handler);
Neutral_Reset_Write(1);
isr_neutral_ClearPending();
isr_calibration_StartEx(&isr_calibration_handler);
CyGlobalIntEnable; //enable global interrupts
//Initialize terminal
terminal_init();
monitor_init();
pedal_restore_calibration_data(); //set min and max values
pedal_set_CAN(); //Setup tunnel from pedal control to CAN
pedal_set_monitor(); //Setup tunnel from pedal control to USB Monitor
// Initialize global variables
EEPROM_ERROR_LED_Write(0);
should_calibrate = false;
// terminal_registerCommand("newCmd", &newCmdRout);
sendNMT(NMT_command_startRemoteNode);
CyDelay(1000);
pedal_node_state = pedal_state_driving;
for(;;){
pedal_fetch_data();
}
for(;;)
{
CyDelay(50);
terminal_run(); // Refresh terminal
if (pedal_node_state == pedal_state_neutral)
{
if (should_calibrate)
{
pedal_node_state = pedal_state_calibrating;
} else if (should_turn_to_drive) {
pedal_node_state = pedal_state_driving;
//Start sending can message for invertor
CAN_invertor_resume();
}
} else if (pedal_node_state == pedal_state_driving) {
if (should_turn_to_neutral) {
pedal_node_state = pedal_state_neutral;
//Stop sending messages for invertor
CAN_invertor_pause();
}
}
//Clear all flags after handling
should_calibrate = false;
should_turn_to_drive = false;
should_turn_to_neutral = false;
uint8_t out_of_range_flag;
double brake_percent = 0, throttle_percent = 0;
double brake_percent_diff = 0, throttle_percent_diff = 0;
uint8_t torque_plausible_flag;
uint8_t brake_plausible_flag;
pedal_fetch_data(); //Update ADC readings
CAN_invertor_update_pedal_state(pedal_node_state);
monitor_update_vechicle_state(pedal_node_state); //Update vecicle state
monitor_status_update_vehicle_state(pedal_node_state);
switch (pedal_node_state)
{
case pedal_state_neutral:
LCD_ClearDisplay();
LCD_Position(0,0);
LCD_PrintString("NEUTRAL");
break;
case pedal_state_driving:
LCD_ClearDisplay();
LCD_Position(0,0);
LCD_PrintString("DRIVING");
//out_of_range_flag = pedal_get_out_of_range_flag();
if (out_of_range_flag != 0)
{
pedal_node_state = pedal_state_out_of_range;
break;
}
torque_plausible_flag = pedal_is_pedal_reading_matched(&brake_percent_diff, &throttle_percent_diff);
if (torque_plausible_flag != 0)
{
pedal_node_state = pedal_state_discrepency;
break;
}
brake_plausible_flag = pedal_is_brake_plausible(&brake_percent, &throttle_percent);
if (brake_plausible_flag != 0)
{
pedal_node_state = pedal_state_implausible;
break;
}
break;
case pedal_state_calibrating:
//clock_StopBlock(); //stop clock to disable interrupt
pedal_calibrate();
LCD_ClearDisplay();
//isr_ClearPending();
//clock_Start();
// isr_calibration_Enable();
pedal_node_state = pedal_state_neutral;
break;
case pedal_state_out_of_range:
LCD_ClearDisplay();
LCD_Position(0,0);
LCD_PrintString("Pedal out of");
LCD_Position(1,0);
LCD_PrintString("range");
out_of_range_flag = pedal_get_out_of_range_flag();
if (out_of_range_flag == 0)
{
pedal_node_state = pedal_state_driving;
}
break;
case pedal_state_discrepency:
LCD_ClearDisplay();
LCD_Position(0,0);
LCD_PrintString("Pedal discrepency");
torque_plausible_flag = pedal_is_pedal_reading_matched(&brake_percent_diff, &throttle_percent_diff);
if (torque_plausible_flag == 0)
{
pedal_node_state = pedal_state_driving;
}
break;
case pedal_state_implausible:
LCD_ClearDisplay();
LCD_Position(0,0);
LCD_PrintString("Pedal implausible");
brake_plausible_flag = pedal_is_brake_plausible(&brake_percent, &throttle_percent);
if (throttle_percent < PEDAL_BRAKE_IMPLAUSIBLE_EXIT_THROTTLE_PERCENT)
{
pedal_node_state = pedal_state_driving;
}
break;
}
// CyDelay(100);
}
return 0;
}
static int can_init(const can_cfg_t *cfg)
{
GPIO_InitTypeDef GPIO_InitStructure;
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
CAN_InitTypeDef CAN_InitStructure;
CAN_FilterInitTypeDef CAN_FilterInitStructure;
RCC_ClocksTypeDef RCC_Clocks;
#ifdef CONFIG_CAN1_REMAP
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
/*RX = PB8, TX = PB9 */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_PinRemapConfig(GPIO_Remap1_CAN1 , ENABLE);
#else
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
/*RX = PA11 TX = PA12 */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
#endif
/* CAN register init */
CAN_DeInit(CAN1);
CAN_StructInit(&CAN_InitStructure);
//get apb clock
RCC_GetClocksFreq(&RCC_Clocks);
/* CAN cell init */
CAN_InitStructure.CAN_TTCM = DISABLE;
CAN_InitStructure.CAN_ABOM = ENABLE;
CAN_InitStructure.CAN_AWUM = DISABLE;
CAN_InitStructure.CAN_NART = DISABLE;
CAN_InitStructure.CAN_RFLM = DISABLE;
CAN_InitStructure.CAN_TXFP = ENABLE;
CAN_InitStructure.CAN_Mode = (cfg -> silent) ? CAN_Mode_Silent : CAN_Mode_Normal;
CAN_InitStructure.CAN_SJW = CAN_SJW_1tq;
CAN_InitStructure.CAN_BS1 = CAN_BS1_3tq;
CAN_InitStructure.CAN_BS2 = CAN_BS2_5tq;
CAN_InitStructure.CAN_Prescaler = RCC_Clocks.PCLK1_Frequency/cfg->baud/(1+3+5);
CAN_Init(CAN1, &CAN_InitStructure);
/* CAN filter init */
CAN_FilterInitStructure.CAN_FilterNumber=0;
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=0 ;
CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;
CAN_FilterInit(&CAN_FilterInitStructure);
#if ENABLE_CAN_INT
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
#ifndef STM32F10X_CL
NVIC_InitStructure.NVIC_IRQChannel = USB_LP_CAN1_RX0_IRQn;
#else
NVIC_InitStructure.NVIC_IRQChannel = CAN1_RX0_IRQn;
#endif
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
CAN_ClearITPendingBit(CAN1, CAN_IT_FMP0);
CAN_ITConfig(CAN1, CAN_IT_FMP0, ENABLE);
circle_header = 0;
circle_tailer = 0;
circle_number = 0;
#endif
can_flush();
return 0;
}
/**
* @brief Configures the CAN, transmit and receive by polling
* @param None
* @retval PASSED if the reception is well done, FAILED in other case
*/
TestStatus CAN_Polling(void)
{
CAN_InitTypeDef sCAN;
CAN_TxMsgTypeDef TxMsg;
CAN_RxMsgTypeDef RxMsg;
uint32_t i = 0;
/* Set the HCLK division factor = 1 for CAN1*/
CAN_BRGInit(MDR_CAN1,CAN_HCLKdiv1);
/* CAN register init */
CAN_DeInit(MDR_CAN1);
/* CAN cell init */
CAN_StructInit (&sCAN);
sCAN.CAN_ROP = ENABLE;
sCAN.CAN_SAP = ENABLE;
sCAN.CAN_STM = ENABLE;
sCAN.CAN_ROM = DISABLE;
sCAN.CAN_PSEG = CAN_PSEG_Mul_2TQ;
sCAN.CAN_SEG1 = CAN_SEG1_Mul_5TQ;
sCAN.CAN_SEG2 = CAN_SEG2_Mul_5TQ;
sCAN.CAN_SJW = CAN_SJW_Mul_4TQ;
sCAN.CAN_SB = CAN_SB_3_SAMPLE;
sCAN.CAN_BRP = 4;
CAN_Init (MDR_CAN1,&sCAN);
CAN_Cmd(MDR_CAN1, ENABLE);
/* Disable all CAN1 interrupt */
CAN_ITConfig( MDR_CAN1, CAN_IT_GLBINTEN | CAN_IT_RXINTEN | CAN_IT_TXINTEN |
CAN_IT_ERRINTEN | CAN_IT_ERROVERINTEN, DISABLE);
/* Enable CAN1 interrupt from receive buffer */
CAN_RxITConfig( MDR_CAN1 ,(1<<rx_buf), ENABLE);
/* Enable CAN1 interrupt from transmit buffer */
CAN_TxITConfig( MDR_CAN1 ,(1<<tx_buf), ENABLE);
/* receive buffer enable */
CAN_Receive(MDR_CAN1, rx_buf, DISABLE);
/* transmit */
TxMsg.IDE = CAN_ID_EXT;
TxMsg.DLC = 0x08;
TxMsg.PRIOR_0 = DISABLE;
TxMsg.ID = 0x12345678;
TxMsg.Data[1] = 0x01234567;
TxMsg.Data[0] = 0x89ABCDEF;
CAN_Transmit(MDR_CAN1, tx_buf, &TxMsg);
i = 0;
while(((CAN_GetStatus(MDR_CAN1) & CAN_STATUS_TX_READY) != RESET) && (i != 0xFFF))
{
i++;
}
CAN_ITClearRxTxPendingBit(MDR_CAN1, tx_buf, CAN_STATUS_TX_READY);
i = 0;
while(((CAN_GetStatus(MDR_CAN1) & CAN_STATUS_RX_READY) == RESET) && (i != 0xFFF))
{
i++;
}
/* receive */
CAN_GetRawReceivedData(MDR_CAN1, rx_buf, &RxMsg);
CAN_ITClearRxTxPendingBit(MDR_CAN1, rx_buf, CAN_STATUS_RX_READY);
CAN_Cmd(MDR_CAN1, DISABLE);
if(RxMsg.Rx_Header.IDE != TxMsg.IDE)
{
return FAILED;
}
if(RxMsg.Rx_Header.DLC != TxMsg.DLC)
{
return FAILED;
}
if(RxMsg.Rx_Header.ID != TxMsg.ID)
{
return FAILED;
}
if(RxMsg.Data[1] != TxMsg.Data[1])
{
return FAILED;
}
if(RxMsg.Data[0] != TxMsg.Data[0])
{
return FAILED;
}
else
{
return PASSED; /* Test Passed */
}
}
/**
* @brief Configures the CAN.
* @param None
* @retval None
*/
void CAN_Config(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
/* GPIO clock enable */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
#ifdef __CAN1_USED__
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIO_CAN1, ENABLE);
#else /*__CAN2_USED__*/
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIO_CAN1, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIO_CAN2, ENABLE);
#endif /* __CAN1_USED__ */
/* Configure CAN pin: RX */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_CAN_RX;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
GPIO_Init(GPIO_CAN, &GPIO_InitStructure);
/* Configure CAN pin: TX */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_CAN_TX;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIO_CAN, &GPIO_InitStructure);
GPIO_PinRemapConfig(GPIO_Remapping_CAN , ENABLE);
/* CANx Periph clock enable */
#ifdef __CAN1_USED__
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
#else /*__CAN2_USED__*/
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN2, ENABLE);
#endif /* __CAN1_USED__ */
/* CAN register init */
CAN_DeInit(CANx);
CAN_StructInit(&CAN_InitStructure);
/* CAN cell init */
CAN_InitStructure.CAN_TTCM = DISABLE;
CAN_InitStructure.CAN_ABOM = DISABLE;
CAN_InitStructure.CAN_AWUM = DISABLE;
CAN_InitStructure.CAN_NART = DISABLE;
CAN_InitStructure.CAN_RFLM = DISABLE;
CAN_InitStructure.CAN_TXFP = DISABLE;
CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;
/* CAN Baudrate = 1MBps*/
CAN_InitStructure.CAN_SJW = CAN_SJW_1tq;
CAN_InitStructure.CAN_BS1 = CAN_BS1_3tq;
CAN_InitStructure.CAN_BS2 = CAN_BS2_5tq;
CAN_InitStructure.CAN_Prescaler = 4;
CAN_Init(CANx, &CAN_InitStructure);
/* CAN filter init */
#ifdef __CAN1_USED__
CAN_FilterInitStructure.CAN_FilterNumber = 0;
#else /*__CAN2_USED__*/
CAN_FilterInitStructure.CAN_FilterNumber = 14;
#endif /* __CAN1_USED__ */
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 = 0;
CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;
CAN_FilterInit(&CAN_FilterInitStructure);
/* Transmit */
TxMessage.StdId = 0x321;
TxMessage.ExtId = 0x01;
TxMessage.RTR = CAN_RTR_DATA;
TxMessage.IDE = CAN_ID_STD;
TxMessage.DLC = 1;
}
/**
* @brief Configures CAN1 and CAN2.
* @param None
* @retval None
*/
void CAN_Config(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
/* Configure CAN1 and CAN2 IOs **********************************************/
/* GPIOB, GPIOD and AFIO clocks enable */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | RCC_APB2Periph_GPIOD | RCC_APB2Periph_GPIOB, ENABLE);
/* Configure CAN1 RX pin */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
GPIO_Init(GPIOD, &GPIO_InitStructure);
/* Configure CAN2 RX pin */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
GPIO_Init(GPIOB, &GPIO_InitStructure);
/* Configure CAN1 TX pin */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOD, &GPIO_InitStructure);
/* Configure CAN2 TX pin */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
GPIO_Init(GPIOB, &GPIO_InitStructure);
/* Remap CAN1 and CAN2 GPIOs */
GPIO_PinRemapConfig(GPIO_Remap2_CAN1 , ENABLE);
GPIO_PinRemapConfig(GPIO_Remap_CAN2, ENABLE);
/* Configure CAN1 and CAN2 **************************************************/
/* CAN1 and CAN2 Periph clocks enable */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1 | RCC_APB1Periph_CAN2, ENABLE);
/* CAN1 and CAN2 register init */
CAN_DeInit(CAN1);
CAN_DeInit(CAN2);
/* Struct init*/
CAN_StructInit(&CAN_InitStructure);
/* CAN1 and CAN2 cell init */
CAN_InitStructure.CAN_TTCM = DISABLE;
CAN_InitStructure.CAN_ABOM = DISABLE;
CAN_InitStructure.CAN_AWUM = DISABLE;
CAN_InitStructure.CAN_NART = DISABLE;
CAN_InitStructure.CAN_RFLM = DISABLE;
CAN_InitStructure.CAN_TXFP = ENABLE;
CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;
CAN_InitStructure.CAN_SJW = CAN_SJW_1tq;
CAN_InitStructure.CAN_BS1 = CAN_BS1_3tq;
CAN_InitStructure.CAN_BS2 = CAN_BS2_2tq;
#if CAN_BAUDRATE == 1000 /* 1MBps */
CAN_InitStructure.CAN_Prescaler =6;
#elif CAN_BAUDRATE == 500 /* 500KBps */
CAN_InitStructure.CAN_Prescaler =12;
#elif CAN_BAUDRATE == 250 /* 250KBps */
CAN_InitStructure.CAN_Prescaler =24;
#elif CAN_BAUDRATE == 125 /* 125KBps */
CAN_InitStructure.CAN_Prescaler =48;
#elif CAN_BAUDRATE == 100 /* 100KBps */
CAN_InitStructure.CAN_Prescaler =60;
#elif CAN_BAUDRATE == 50 /* 50KBps */
CAN_InitStructure.CAN_Prescaler =120;
#elif CAN_BAUDRATE == 20 /* 20KBps */
CAN_InitStructure.CAN_Prescaler =300;
#elif CAN_BAUDRATE == 10 /* 10KBps */
CAN_InitStructure.CAN_Prescaler =600;
#else
#error "Please select first the CAN Baudrate in Private defines in main.c "
#endif /* CAN_BAUDRATE == 1000 */
/*Initializes the CAN1 and CAN2 */
CAN_Init(CAN1, &CAN_InitStructure);
CAN_Init(CAN2, &CAN_InitStructure);
/* CAN1 filter init */
CAN_FilterInitStructure.CAN_FilterNumber = 1;
CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdMask;
CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit;
CAN_FilterInitStructure.CAN_FilterIdHigh = 0x6420;
CAN_FilterInitStructure.CAN_FilterIdLow = 0x0000;
CAN_FilterInitStructure.CAN_FilterMaskIdHigh = 0x0000;
CAN_FilterInitStructure.CAN_FilterMaskIdLow = 0x0000;
CAN_FilterInitStructure.CAN_FilterFIFOAssignment = 0;
CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;
CAN_FilterInit(&CAN_FilterInitStructure);
/* CAN2 filter init */
CAN_FilterInitStructure.CAN_FilterIdHigh =0x2460;
CAN_FilterInitStructure.CAN_FilterNumber = 15;
CAN_FilterInit(&CAN_FilterInitStructure);
/* Transmit */
TxMessage.StdId = 0x321;
TxMessage.ExtId = 0x01;
TxMessage.RTR = CAN_RTR_DATA;
TxMessage.IDE = CAN_ID_STD;
TxMessage.DLC = 1;
}
