motor/BSP/bsp.c

#include "bsp.h"
#include "string.h"


#define ID_TYPE ID_TYPE_MOT;


unsigned char SYS_getID(void)
{
	unsigned char id = 0;
	
	//unsigned pin_dir = 0;    //引脚顺序为正向  
	//unsigned level_dir = 0;  //电平方向
		
	id <<= 0x01;
	id |=  (HAL_GPIO_ReadPin(ID_6_GPIO_Port,ID_6_Pin) == GPIO_PIN_SET)?(0x00):(0x01);
	  
	id <<= 0x01;
	id |=  (HAL_GPIO_ReadPin(ID_5_GPIO_Port,ID_5_Pin) == GPIO_PIN_SET)?(0x00):(0x01);
	  
	id <<= 0x01;
	id |=  (HAL_GPIO_ReadPin(ID_4_GPIO_Port,ID_4_Pin) == GPIO_PIN_SET)?(0x00):(0x01);
	  
	id <<= 0x01;
	id |=  (HAL_GPIO_ReadPin(ID_3_GPIO_Port,ID_3_Pin) == GPIO_PIN_SET)?(0x00):(0x01);
	  
	id <<= 0x01;
	id |=  (HAL_GPIO_ReadPin(ID_2_GPIO_Port,ID_2_Pin) == GPIO_PIN_SET)?(0x00):(0x01);
	  
	id <<= 0x01;
	id |=  (HAL_GPIO_ReadPin(ID_1_GPIO_Port,ID_1_Pin) == GPIO_PIN_SET)?(0x00):(0x01);
	
	id |= ID_TYPE;
	
	return id;
}

unsigned char SYS_getKey(void)
{
	volatile unsigned char state = 0;
	
	state <<= 0x01;
	state |=  (HAL_GPIO_ReadPin(DI_MAX_GPIO_Port,DI_MAX_Pin) == GPIO_PIN_SET)?(0x01):(0x00);
	  
	state <<= 0x01;
	state |=  (HAL_GPIO_ReadPin(DI_MIN_GPIO_Port,DI_MIN_Pin) == GPIO_PIN_SET)?(0x01):(0x00);
	  
	
	return state;
}

void COMM_setSel(COMM_TYPE_ENUM type)
{
	switch(type)
	{
		default:
		case COMM_TYPE_485:
		{
			HAL_GPIO_WritePin(COM_SEL_GPIO_Port,COM_SEL_Pin,GPIO_PIN_RESET);
		}break;
		case COMM_TYPE_CAN:
		{
			HAL_GPIO_WritePin(COM_SEL_GPIO_Port,COM_SEL_Pin,GPIO_PIN_SET);
		}break;
	}
}

void COMM_setDir(COMM_DIR_ENUM dir)
{
	switch(dir)
	{
		default:
		case COMM_DIR_RX:
		{
			//HAL_Delay(2);
			HAL_GPIO_WritePin(CTRL_485_GPIO_Port,CTRL_485_Pin,GPIO_PIN_RESET);
			//HAL_Delay(2);
		}break;
		case COMM_DIR_TX:
		{
			//HAL_Delay(2);
			HAL_GPIO_WritePin(CTRL_485_GPIO_Port,CTRL_485_Pin,GPIO_PIN_SET);
			//HAL_Delay(2);
		}break;
	}
}




void LED_setState(LED_CHANNEL_ENUM channel,LED_STATE_ENUM state)
{
	switch(channel)
	{
		default:
		case LED_GREEN:
		{
			HAL_GPIO_WritePin(LED1_GPIO_Port,LED1_Pin,(state)?(GPIO_PIN_RESET):(GPIO_PIN_SET));

		}break;
		case LED_RED:
		{
			HAL_GPIO_WritePin(LED2_GPIO_Port,LED2_Pin,(state)?(GPIO_PIN_RESET):(GPIO_PIN_SET));
		}break;
	}
}

void LED_setToggle(LED_CHANNEL_ENUM channel)
{
	switch(channel)
	{
		default:
		case LED_GREEN:
		{
			HAL_GPIO_TogglePin(LED1_GPIO_Port,LED1_Pin);

		}break;
		case LED_RED:
		{
			HAL_GPIO_TogglePin(LED2_GPIO_Port,LED2_Pin);
		}break;
	}
}




void MOTOR_setMS(MOTOR_MS_ENUM ms)
{
	switch(ms)
	{
		default:
		case MOTOR_MS_8:
		{
			HAL_GPIO_WritePin(M_MS1_GPIO_Port,M_MS1_Pin,GPIO_PIN_RESET);
			HAL_GPIO_WritePin(M_MS2_GPIO_Port,M_MS2_Pin,GPIO_PIN_RESET);
		}break;
		case MOTOR_MS_16:
		{
			HAL_GPIO_WritePin(M_MS1_GPIO_Port,M_MS1_Pin,GPIO_PIN_SET);
			HAL_GPIO_WritePin(M_MS2_GPIO_Port,M_MS2_Pin,GPIO_PIN_SET);
		}break;
		case MOTOR_MS_32:
		{
			HAL_GPIO_WritePin(M_MS1_GPIO_Port,M_MS1_Pin,GPIO_PIN_SET);
			HAL_GPIO_WritePin(M_MS2_GPIO_Port,M_MS2_Pin,GPIO_PIN_RESET);
		}break;
		case MOTOR_MS_64:
		{
			HAL_GPIO_WritePin(M_MS1_GPIO_Port,M_MS1_Pin,GPIO_PIN_RESET);
			HAL_GPIO_WritePin(M_MS2_GPIO_Port,M_MS2_Pin,GPIO_PIN_SET);
		}break;
	}
}

void MOTOR_setEn(MOTOR_STATE_ENUM state)
{
	switch(state)
	{
		default:
		case MOTOR_DISNABLE:
		{
			HAL_GPIO_WritePin(M_EN_GPIO_Port,M_EN_Pin,GPIO_PIN_RESET);
		}break;
		case MOTOR_ENABLE:
		{
			HAL_GPIO_WritePin(M_EN_GPIO_Port,M_EN_Pin,GPIO_PIN_SET);
		}break;
		
	}
}

void MOTOR_setDir(MOTOR_DIR_ENUM dir)
{
	switch(dir)
	{
		default:
		case MOTOR_DIR_CW:
		{
			HAL_GPIO_WritePin(M_DIR_GPIO_Port,M_DIR_Pin,GPIO_PIN_SET);
		}break;
		case MOTOR_DIR_CCW:
		{
			HAL_GPIO_WritePin(M_DIR_GPIO_Port,M_DIR_Pin,GPIO_PIN_RESET);
		}break;
		
	}
}

void MOTOR_setStep(unsigned char step)
{
	if(step)
	{
		HAL_GPIO_WritePin(M_STEP_GPIO_Port,M_STEP_Pin,GPIO_PIN_SET);
	}
	else
	{
		HAL_GPIO_WritePin(M_STEP_GPIO_Port,M_STEP_Pin,GPIO_PIN_RESET);
	}
}




static SERIAL_t *serials = NULL;

SERIAL_t serial1;
SERIAL_t serial3;


int SERIAL_Init(SERIAL_t *serial,char *name,UART_HandleTypeDef *huart,size_t send_len, size_t recv_len)
{
	serial->huart = huart;
	serial->name = name;
	serial->recv_buff_len = recv_len;
	serial->recv_buff = (uint8_t *)malloc(recv_len);
	if (!serial->recv_buff)//检查是否分配成功
	{
	  return -1;
	}
	serial->recv_head = 0u;
	serial->recv_tail = 0u;
	
	
	
	serial->send_buff_len = send_len;

	serial->send_head = 0u;
	serial->send_buff[0] = (uint8_t *)malloc(send_len*2);
	if (!serial->send_buff[0])
	{
	  return -1;
	}
	serial->send_buff[1] = serial->send_buff[0]+send_len;
	
	
	serial->isbusy = 0;
	
	
	serial->next_ptr = NULL;
	
	if (serials)
	{
		SERIAL_t *head = serials;
		while (head->next_ptr)
		{
		  head = head->next_ptr;
		}
	  head->next_ptr = serial;
	}
	else
	{
	  serials = serial;
	}
	
	

	
	return 0;
	
}

void SERIAL_StartRecv(SERIAL_t *serial)
{
	if(serial->setDir)
	{
		serial->setDir(COMM_DIR_RX);
	}
	
		/* 总线繁忙 */
	serial->isbusy = 1;
	
	
	__HAL_UART_CLEAR_OREFLAG(serial->huart);//clear Overrun Error Clear Flag

	__HAL_UART_ENABLE_IT(serial->huart, UART_IT_IDLE);//enable idle int
	
	//打开接收中断
	//HAL_UART_Receive_IT(serial->huart,serial->recv_buff,serial->recv_buff_len);
	HAL_UARTEx_ReceiveToIdle_IT(serial->huart,serial->recv_buff,serial->recv_buff_len);
}

void SERIAL_StopRecv(SERIAL_t *serial)
{
		/* 总线繁忙 */
	serial->isbusy = 0;

	__HAL_UART_DISABLE_IT(serial->huart, UART_IT_IDLE);//enable idle int
	__HAL_UART_DISABLE_IT(serial->huart,UART_IT_RXNE);
	__HAL_UART_CLEAR_OREFLAG(serial->huart);//clear Overrun Error Clear Flag
	
	HAL_UART_AbortReceive_IT(serial->huart);
	
	//打开接收中断
}




static void SERIAL_sendstr(SERIAL_t *serial)
{
	if (serial->send_head)
	{
		 if (serial->send_max_used_len < serial->send_head)
		 {
			 serial->send_max_used_len = serial->send_head;
		 }
		 HAL_StatusTypeDef ret;

		 if(serial->setDir)
		 {
			 //先停止接收
			 
			 
			 //SERIAL_StopRecv(serial);
			 //HAL_Delay(20);
			 //如果总线不忙，那么发送，否则等待
			 serial->setDir(COMM_DIR_TX);	
		 }
		 
		 
		 ret = HAL_UART_Transmit_IT(serial->huart,serial->send_buff[serial->sel],serial->send_head);
		 
		 if (ret == HAL_OK)
		 {
		   serial->sending = true;
		   serial->send_head = 0u;
		   serial->sel = serial->sel?0:1;
		 }
		 else
		 {
		   
		 }
	}
	else
	{
		 if(serial->setDir)
		 {
			 //HAL_Delay(20);
			serial->setDir(COMM_DIR_RX);
			 
			//SERIAL_StartRecv(serial);
			 
		 }
		 serial->sending = false; 
	}
}



bool SERIAL_Write(SERIAL_t *serial, uint8_t *data, size_t len)
{
	bool rslt = false;

	if (serial->send_head + len <= serial->send_buff_len)
	{
		memcpy(serial->send_buff[serial->sel] + serial->send_head,data,len);
		//给head加上尺寸
		serial->send_head += len;
	 
		if(!serial->sending)
		{
			SERIAL_sendstr(serial);
		}
	  rslt = true;
	}
	else
	{
		if (serial->send_max_used_len < serial->send_head + len) 
		{
			serial->send_max_used_len = serial->send_head + len;
		}
    }

	
	return rslt;
}




size_t SERIAL_getlen(SERIAL_t *serial)
{
	size_t head;
	size_t used_len;
	
	head = serial->recv_head;
	
	if (head >= serial->recv_tail)
	{
		if(head == serial->recv_tail)
		{
			if(serial->isOverLoop)
			{
				serial->isOverLoop = 0;
				used_len = serial->recv_buff_len;
			}
			else
			{
				used_len = 0;
			}
		}
		else
		{
			used_len = head - serial->recv_tail;
		}
	}
	else
	{
		used_len = head + serial->recv_buff_len - serial->recv_tail;
	}
	if (used_len > serial->recv_max_used_len)
	{
		serial->recv_max_used_len = used_len;
	}
   return used_len;
}


size_t SERIAL_Read(SERIAL_t *serial, uint8_t *buff, size_t maxlen)
{
	size_t rslt = 0u;

	rslt = SERIAL_getlen(serial);
	if (rslt > maxlen)
	{
	  rslt = maxlen;
	}

	for (size_t i=0u;i<rslt;++i)
	{
		buff[i] = serial->recv_buff[serial->recv_tail++];
		if (serial->recv_tail >= serial->recv_buff_len)
		{
			serial->recv_tail = 0u;
		}
	}

	return rslt;
}




void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	SERIAL_t *serial = serials;
	while (serial)
	{
		if (serial->huart == huart)
		{
			serial->recv_head = 0u;
			//HAL_UART_Receive_IT(serial->huart,serial->recv_buff,serial->recv_buff_len);
			HAL_UARTEx_ReceiveToIdle_IT(serial->huart,serial->recv_buff,serial->recv_buff_len);
			break;
		}
		else
		{
		  serial = serial->next_ptr;
		}
	}
}

//空闲中断回调函数，参数Size为串口实际接收到数据字节数
void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size)
{	
	SERIAL_t *serial = serials;
	while (serial)
	{
		if (serial->huart == huart)
		{	
			if(Size)
			{
				if((serial->recv_head + Size) >= serial->recv_buff_len)
				{
					serial->recv_head = Size + serial->recv_head - serial->recv_buff_len;
				}
				else
				{
					serial->recv_head += Size;
				}
				
				if(serial->recv_head == serial->recv_tail)
				{
					serial->isOverLoop = 1;//超过了一圈，只能超一圈，超两圈会覆盖
				}
			}
			//HAL_UART_Receive_IT(serial->huart,(serial->recv_buff + serial->recv_head),serial->recv_buff_len - serial->recv_head);
			HAL_UARTEx_ReceiveToIdle_IT(serial->huart,(serial->recv_buff + serial->recv_head),serial->recv_buff_len - serial->recv_head);
			break;
		}
		else
		{
		  serial = serial->next_ptr;
		}
	}
}





void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
	
	SERIAL_t *serial = serials;
	while (serial)
	{
		if (serial->huart == huart)
		{
			SERIAL_sendstr(serial);
			break;
		}
		else
		{
		  
		  serial = serial->next_ptr;
		}
	}
	
}


void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
{
	if (huart->ErrorCode != HAL_UART_ERROR_NONE)
	{
		SERIAL_t *serial = serials;
		while (serial)
		{
			if (serial->huart == huart)
			{
				//printf("%s UART ERR%lu!\n",serial->name, huart->ErrorCode);
				serial->sending = false;
				serial->send_head = 0;
				
				__HAL_UART_CLEAR_OREFLAG(huart);//clear Overrun Error Clear Flag
				
				__HAL_UART_CLEAR_IDLEFLAG(serial->huart);
				__HAL_UART_DISABLE_IT(serial->huart,UART_IT_RXNE);
				HAL_UART_AbortReceive_IT(serial->huart);
				
				//打开接收
				//HAL_UART_Receive_IT(serial->huart,serial->recv_buff,serial->recv_buff_len);
				HAL_UARTEx_ReceiveToIdle_IT(serial->huart,serial->recv_buff,serial->recv_buff_len);
				
				break;
			}
			else
			{
				serial = serial->next_ptr;
			}
		}
	}
}

void HAL_UART_IdleCpltCallback(UART_HandleTypeDef *huart)
{

}


//===============time====================

#define MAIN_PERIOD_MS (5)

uint32_t tick_ms = 0;
uint32_t tick_us = 0;
volatile uint32_t tick_count_200Hz = 0;



void tick_init(void)
{
	HAL_TIM_Base_Start_IT(&htim2);
}

void tick_count(void)
{
	tick_ms += 1;
    tick_us += 1000;
	
	if(!(tick_ms % MAIN_PERIOD_MS))
	{
		tick_count_200Hz += 1;
	}
}



uint32_t get_ticks_msec(void)
{
    return tick_ms;
}

uint32_t get_ticks_usec(void)
{
    return tick_us + TIM2->CNT;
}


void HAL_Delay_usec(uint32_t ticks_usec)
{
    uint32_t tick0;
    uint32_t tick1;
    uint32_t dtick;

    tick0 = get_ticks_usec();
    do
    {
        tick1 = get_ticks_usec();
        if (tick1 >= tick0)
        {
            dtick = tick1 - tick0;
        }
        else
        {
            dtick = (0xFFFFFFFF - tick0) + tick1;
        }
    } while (dtick < ticks_usec);
}