632 lines
11 KiB
C
632 lines
11 KiB
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);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|