/**
* ISR for CAN. Normal Tx operation
*
* @param unit CAN controller number( from 0 )
*/
static void Can_TxIsr(int unit) {
CAN_HW_t *canHw= GetController(unit);
const Can_ControllerConfigType *canHwConfig= CAN_GET_CONTROLLER_CONFIG(Can_Global.channelMap[unit]);
Can_UnitType *canUnit = CAN_GET_PRIVATE_DATA(unit);
const Can_HardwareObjectType *hohObj;
// Loop over all the Hoh's
hohObj= canHwConfig->Can_Hoh;
--hohObj;
do {
++hohObj;
if (hohObj->CanObjectType == CAN_OBJECT_TYPE_TRANSMIT)
{
CanIf_TxConfirmation(canUnit->swPduHandle);
canUnit->swPduHandle = 0; // Is this really necessary ??
// Clear Tx interrupt
CAN_ClearITPendingBit(canHw,CAN_IT_RQCP0);
CAN_ClearITPendingBit(canHw,CAN_IT_RQCP1);
CAN_ClearITPendingBit(canHw,CAN_IT_RQCP2);
}
} while ( !hohObj->Can_EOL);
}
/**
* Hardware error ISR for CAN
*
* @param unit CAN controller number( from 0 )
*/
static void Can_ErrIsr( int unit ) {
CAN_HW_t *canHw = GetController(unit);
Can_UnitType *canUnit = CAN_GET_PRIVATE_DATA(unit);
Can_Arc_ErrorType err;
err.R = 0;
// Check wake up
if(SET == CAN_GetITStatus(canHw, CAN_IT_WKU)){
Can_WakeIsr(unit);
CAN_ClearITPendingBit(canHw, CAN_IT_WKU);
}
if(SET == CAN_GetITStatus(canHw, CAN_IT_BOF)){
canUnit->stats.boffCnt++;
CanIf_ControllerBusOff(unit);
Can_SetControllerMode(unit, CAN_T_STOP); // CANIF272
Can_AbortTx( canHw, canUnit ); // CANIF273
// Clear int
CAN_ClearITPendingBit(canHw, CAN_IT_BOF);
}
if (err.R != 0)
{
CanIf_Arc_Error( unit, err );
}
}
void USB_HP_CAN1_TX_IRQHandler(void) //CAN TX
{//发送成功进入中断
if (CAN_GetITStatus(CAN1,CAN_IT_TME)!= RESET)
{
CAN_ClearITPendingBit(CAN1,CAN_IT_TME);
}
}
/**
* @brief This function handles CAN1 TX irq and sends more data if available
*/
static void PIOS_CAN_TxGeneric(void)
{
CAN_ClearITPendingBit(can_dev->cfg->regs, CAN_IT_TME);
bool valid = PIOS_CAN_validate(can_dev);
PIOS_Assert(valid);
bool tx_need_yield = false;
if (can_dev->tx_out_cb) {
// Prepare CAN message structure
CanTxMsg msg;
msg.StdId = CAN_COM_ID;
msg.ExtId = 0;
msg.IDE = CAN_ID_STD;
msg.RTR = CAN_RTR_DATA;
msg.DLC = (can_dev->tx_out_cb)(can_dev->tx_out_context, msg.Data, MAX_SEND_LEN, NULL, &tx_need_yield);
// Send message and get mailbox number
if (msg.DLC > 0) {
CAN_Transmit(can_dev->cfg->regs, &msg);
} else {
CAN_ITConfig(can_dev->cfg->regs, CAN_IT_TME, DISABLE);
}
// TODO: deal with failure to send and keep the message to retransmit
}
#if defined(PIOS_INCLUDE_FREERTOS)
portEND_SWITCHING_ISR(tx_need_yield ? pdTRUE : pdFALSE);
#endif /* defined(PIOS_INCLUDE_FREERTOS) */
}
//↑今までの割込み関数
//↓今回変更した割込み関数
void CAN1_TX_IRQHandler(void)
{
if (CAN_GetITStatus(CAN1,CAN_IT_TME)){//メールボックスが空になったら呼び出される 何も送ってない状態では呼び出されない
GPIOD->BSRRL = GPIO_Pin_14;
//CAN_Transmit_List_Stack(1,&can_tx_flame);//can_tx_flameに次に送るデータを格納する
CAN_Transmit(CAN1, &can_tx_flame);//送信
CAN_ClearITPendingBit(CAN1,CAN_IT_TME);
}
}
/*******************************************************************************
* Function Name : CAN_RX0_CALLBACK
* Description : CAN0接收的回调函数
* Input : None
* Output : None
* Return : None
*******************************************************************************/
void CAN_RX0_CALLBACK(void)
{
if (CAN_GetITStatus(CAN1,CAN_IT_FMP0)!= RESET)
{
CAN_ClearITPendingBit(CAN1, CAN_IT_FMP0);
g_CAN_Rx_Provider++;
if(g_CAN_Rx_Provider >= CAN_RX_BUFFER_SIZE)
g_CAN_Rx_Provider = 0;
CAN_Receive(CAN1, CAN_FIFO0, &g_CAN_Rx_message[g_CAN_Rx_Provider]);
}
}
void CAN1_RX0_IRQHandler(void)
{
CanRxMsg RxMessage;
//CAN_Receive(CAN1, CAN_FIFO0, &RxMessage);
//myRxMessage1 =RxMessage;
if(SET == CAN_GetITStatus(CAN1, CAN_IT_FF0))
{
CAN_ClearITPendingBit(CAN1, CAN_IT_FF0);
}
else if(SET == CAN_GetITStatus(CAN1, CAN_IT_FOV0))
{
CAN_ClearITPendingBit(CAN1, CAN_IT_FOV0);
}
else
{
CAN_ClearITPendingBit(CAN1, CAN_IT_FMP0);
CAN_Receive(CAN1, CAN_FIFO0, &RxMessage);
FIFO_PUT_ONE(CAN1_RxFifo, RxMessage);
}
}
//CAN1接收中断调用函数
void DST_CAN_1::CAN1_RX0_IRQHandler_Fun(void)
{
if(CAN_GetITStatus(CAN1,CAN_IT_FMP0)!= RESET)
{
CAN_ClearITPendingBit(CAN1, CAN_IT_FMP0);
CAN_Receive(CAN1, CAN_FIFO0, &can1_rx_msg);
/********HG900 6025数据接收********/
_data_pro.HG900_6025_DataPro(&can1_rx_msg);//CAN1云台数据处理
//test fun
ws(&can1_rx_msg);
}
}
void CAN1_RX0_IRQHandler(void)
{
CanRxMsg rx_message;
if (CAN_GetITStatus(CAN1, CAN_IT_FMP0) != RESET)
{
CAN_ClearITPendingBit(CAN1, CAN_IT_FMP0);
CAN_Receive(CAN1, CAN_FIFO0, &rx_message);
if(can1_rh)
can1_rh(&rx_message);
}
}
void USB_LP_CAN1_RX0_IRQHandler(void)
{
OS_CPU_SR cpu_sr = 0;
OS_ENTER_CRITICAL(); // 进入临界区(无法被中断打断)
CAN_Receive(CAN1, CAN_FIFO0, &rxMessage);
CANRxDeal(&rxMessage);
CAN_ClearITPendingBit(CAN1, CAN_IT_FMP0);
OS_EXIT_CRITICAL(); // 退出临界区(可以被中断打断)
}
void USB_LP_CAN1_RX0_IRQHandler(void) {
if (CAN_GetITStatus(CAN1, CAN_IT_FMP0) == RESET) {
return;
}
CAN_ClearITPendingBit(CAN1, CAN_IT_FMP0);
//GPIO_ResetBits(GPIOA, GPIO_Pin_8);
CanRxMsg message;
while(CAN_MessagePending(CAN1, 0)) {
CAN_Receive(CAN1, 0, &message);
}
if (GPIO_ReadOutputDataBit(GPIOA, GPIO_Pin_8) == Bit_SET) {
GPIO_ResetBits(GPIOA, GPIO_Pin_8);
} else {
GPIO_SetBits(GPIOA, GPIO_Pin_8);
}
}
void USB_LP_CAN1_RX0_IRQHandler(void)
{
if(CAN_GetITStatus(CAN1, CAN_IT_FMP0))
{
CAN_ClearITPendingBit(CAN1, CAN_IT_FMP0);
CAN_Receive(CAN1, 0, &CanRxMsgStructure);
for(countCAN = 0; countCAN < 8; countCAN++)
{
USART_SendData(USART2, CanRxMsgStructure.Data[countCAN]);
while(!USART_GetFlagStatus(USART2, USART_FLAG_TC));
USART_ClearFlag(USART2, USART_FLAG_TC);
}
autoSendFlag++;
startFlag = 1;
}
}
//for can1 receive FIFO 0 interrupt
void USB_LP_CAN1_RX0_IRQHandler(void)
{
CanRxMsg msg_st;
CAN_ClearITPendingBit(CAN1, CAN_IT_FMP0);
while (CAN_MessagePending(CAN1, CAN_FIFO0)) {
CAN_Receive(CAN1, CAN_FIFO0, &msg_st);
circle_number ++;
#if CONFIG_CAN1_FIFO_OVERRIDE
can_fifo_rx[circle_header].id = (msg_st.IDE == CAN_ID_EXT) ? msg_st.ExtId : msg_st.StdId;
can_fifo_rx[circle_header].flag = (msg_st.IDE == CAN_ID_EXT) ? CAN_FLAG_EXT : 0;
can_fifo_rx[circle_header].dlc = msg_st.DLC;
memcpy(can_fifo_rx[circle_header].data, msg_st.Data, msg_st.DLC);
if (circle_number == RX_FIFO_SZ) {
circle_number --;
circle_tailer++;
if (circle_tailer == RX_FIFO_SZ)
circle_tailer = 0;
}
circle_header ++;
if (circle_header == RX_FIFO_SZ)
circle_header = 0;
#else
if (circle_number == RX_FIFO_SZ) {
circle_number --;
return;
}
can_fifo_rx[circle_header].id = (msg_st.IDE == CAN_ID_EXT) ? msg_st.ExtId : msg_st.StdId;
can_fifo_rx[circle_header].flag = (msg_st.IDE == CAN_ID_EXT) ? CAN_FLAG_EXT : 0;
can_fifo_rx[circle_header].dlc = msg_st.DLC;
memcpy(can_fifo_rx[circle_header].data, msg_st.Data, msg_st.DLC);
circle_header ++;
if (circle_header == RX_FIFO_SZ)
circle_header = 0;
#endif
}
}
/**
* @brief This function handles CAN1 RX1 request.
* @note We are using RX1 instead of RX0 to avoid conflicts with the
* USB IRQ handler.
*/
static void PIOS_CAN_RxGeneric(void)
{
CAN_ClearITPendingBit(can_dev->cfg->regs, CAN_IT_FMP1);
bool valid = PIOS_CAN_validate(can_dev);
PIOS_Assert(valid);
CanRxMsg RxMessage;
CAN_Receive(CAN1, CAN_FIFO1, &RxMessage);
bool rx_need_yield = false;
if (RxMessage.StdId == CAN_COM_ID) {
if (can_dev->rx_in_cb) {
(void) (can_dev->rx_in_cb)(can_dev->rx_in_context, RxMessage.Data, RxMessage.DLC, NULL, &rx_need_yield);
}
} else {
rx_need_yield = process_received_message(RxMessage);
}
#if defined(PIOS_INCLUDE_FREERTOS)
portEND_SWITCHING_ISR(rx_need_yield ? pdTRUE : pdFALSE);
#endif /* defined(PIOS_INCLUDE_FREERTOS) */
}
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;
}
/*************************************************************************
CAN2_RX0_IRQHandler
���������������ǡ���������CAN���ݽ����ж�
*************************************************************************/
void CAN2_RX0_IRQHandler(void)
{
CanRxMsg rx_message;
if (CAN_GetITStatus(CAN2,CAN_IT_FMP0)!= RESET)
{
CAN_ClearITPendingBit(CAN2, CAN_IT_FMP0);
CAN_Receive(CAN2, CAN_FIFO0, &rx_message);
//��������������
if(rx_message.StdId == 0x401)
{
gyro_ok_flag = 1;
temp_yaw_angle = (int32_t)(rx_message.Data[0]<<24)|(int32_t)(rx_message.Data[1]<<16)
| (int32_t)(rx_message.Data[2]<<8) | (int32_t)(rx_message.Data[3]);
last_yaw_angle = this_yaw_angle;
this_yaw_angle = -((float)temp_yaw_angle*0.01);
}
//ң���� ��� ��̨ͨ��
if(rx_message.StdId == 0x402)
{
temp_yaw = (uint16_t)(rx_message.Data[0]<<8)|(uint16_t)(rx_message.Data[1]);
temp_pitch = (uint16_t)(rx_message.Data[2]<<8)|(uint16_t)(rx_message.Data[3]);
shooting_flag = (uint8_t)rx_message.Data[4];
mode_flag = (uint8_t)rx_message.Data[6];//S2 ����
//for mouse
if(shooting_flag == 1) //cyq:��ǹ
{
if(ShootFlag == 1)
{
Motor_PWM_Set(MOTOR_NUM1,-1000);
ShootFlag=0;
}
}
else
{
if(ShootFlag == 0)
{
ShootFlag=1;
}
}
if (mode_flag == 1)
{
target_pitch_angle += (temp_pitch - 1024)/66.0;//ң��
target_yaw_angle += (temp_yaw - 1024)/600.0 ;//cyq
}
else
{
target_pitch_angle -= (temp_pitch - 1024)/10.0;//cyq �������
target_yaw_angle += (temp_yaw - 1024)/10.0 ;//cyq:����µij���
}
if(target_pitch_angle > pitch_max)
{
target_pitch_angle = pitch_max;
}
else if(target_pitch_angle < -pitch_max)
{
target_pitch_angle = -pitch_max;
}
}
}
}
