wxsmart-test
/
torsion
Archived
7
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

备份，未完成

This commit is contained in:
草团君 2024-04-16 17:06:22 +08:00
parent fba5f0720c
commit 4c3cb563ee
10 changed files with 1248 additions and 1006 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Core/Src/stm32l0xx_it.c
View File

@ -202,6 +202,7 @@ void TIM21_IRQHandler(void)
/* USER CODE BEGIN TIM21_IRQn 1 */
if (LL_TIM_IsActiveFlag_UPDATE(TIM21))
{
step_motor_update(motor);
LL_TIM_ClearFlag_UPDATE(TIM21);
}
/* USER CODE END TIM21_IRQn 1 */

1826
MDK-ARM/motor/motor.hex
View File

File diff suppressed because it is too large Load Diff

47
MDK-ARM/motor/motor.lnp
View File

@ -1,47 +0,0 @@
--cpu Cortex-M0+
"motor\startup_stm32l072xx.o"
"motor\main.o"
"motor\gpio.o"
"motor\adc.o"
"motor\dma.o"
"motor\tim.o"
"motor\usart.o"
"motor\stm32l0xx_it.o"
"motor\stm32l0xx_ll_gpio.o"
"motor\stm32l0xx_ll_adc.o"
"motor\stm32l0xx_ll_dma.o"
"motor\stm32l0xx_ll_rcc.o"
"motor\stm32l0xx_ll_utils.o"
"motor\stm32l0xx_ll_exti.o"
"motor\stm32l0xx_ll_pwr.o"
"motor\stm32l0xx_ll_tim.o"
"motor\stm32l0xx_ll_usart.o"
"motor\system_stm32l0xx.o"
"motor\app.o"
"motor\app_flow.o"
"motor\aes.o"
"motor\clist.o"
"motor\cmac.o"
"motor\cmd.o"
"motor\data_analysis.o"
"motor\debug.o"
"motor\filter.o"
"motor\lib.o"
"motor\malloc.o"
"motor\mlist.o"
"motor\pbuf.o"
"motor\sqqueue.o"
"motor\flow_core.o"
"motor\btn.o"
"motor\delay.o"
"motor\sys.o"
"motor\adcs.o"
"motor\gpios.o"
"motor\pwms.o"
"motor\uarts.o"
"motor\board.o"
"motor\motor.o"
--strict --scatter "motor\motor.sct"
--summary_stderr --info summarysizes --map --load_addr_map_info --xref --callgraph --symbols
--info sizes --info totals --info unused --info veneers
--list "motor.map" -o motor\motor.axf

3
User/app.c
View File

@ -1,5 +1,5 @@
#include "app.h"
// #include "board.h"
#include "board.h"
#include "uarts.h"
#include "sys.h"
#include <stdio.h>
@ -12,6 +12,7 @@ uint8_t mem_percent = 0; // 内存使用率
void app_init(void)
{
motor_process_init();
flow_init(); // 流程初始化
}

2
User/app.h
View File

@ -15,6 +15,8 @@ typedef struct
typedef struct
{
calibration_sensor_data_t torsion_in13; // 扭力
calibration_sensor_data_t pressure_in7; // 压力
calibration_sensor_data_t pressure_in8; // 流量
} adcs_t;
typedef struct

12
User/app_flow.c
View File

@ -17,7 +17,15 @@ static uint8_t adc_inspection(struct flow *fl)
FL_HEAD(fl);
for (;;)
{
app.adc.torsion_in13.original_value = adc_get_result_average(IN13);
// 扭力
app.adc.torsion_in13.original_value = get_torsion_adc();
app.adc.torsion_in13.calibration_value = torsion_detect();
// 压力
app.adc.pressure_in7.original_value = get_pressure_adc();
app.adc.pressure_in7.calibration_value = pressure_detect();
// 流量
app.adc.pressure_in8.original_value = get_flow_adc();
app.adc.pressure_in8.calibration_value = flow_detect();
FL_LOCK_DELAY(fl, FL_CLOCK_100MSEC); /* 延时100毫秒 */
}
FL_TAIL(fl);
@ -28,7 +36,7 @@ static uint8_t systom_inspection(struct flow *fl)
FL_HEAD(fl);
for (;;)
{
host_data_deal();
host_rx_msg_deal();
FL_LOCK_DELAY(fl, FL_CLOCK_10MSEC); /* 延时100毫秒 */
}
FL_TAIL(fl);

310
User/board/board.c
View File

@ -6,10 +6,10 @@ void sensor_procss(frame_msg_t *rx, frame_msg_t *bk);
/************************************* 串口通讯 *************************************/
uart_t *uarts[UART_NUM_MAX];
__IO static BOOL deal_done_flag = 0; // 数据处理标志
__IO static frame_msg_t rx_frame;
__IO static frame_msg_t bk_frame;
__IO static uint8_t send_buffer[UART_TXSIZE];
__IO static BOOL execute_state = 0; // 数据处理标志
static frame_msg_t rx_msg; // 接收数据句柄
static frame_msg_t bk_msg; // 回复数据句柄
static uint8_t host_send_buffer[UART_TXSIZE] = {0}; // 数据发送缓存
// 串口发送
static void host_send_msg(uint8_t *data, uint16_t len)
@ -17,65 +17,56 @@ static void host_send_msg(uint8_t *data, uint16_t len)
uart_send_data(uarts[UART_NUM_1], data, len);
}
// 接收数据解码
static void host_data_decode(uint8_t *data, uint16_t len, frame_msg_t *msg)
// 数据有效性检查
static BOOL host_data_verify(uint8_t *data, uint16_t len)
{
DBG_ASSERT(data != NULL __DBG_LINE);
DBG_ASSERT(msg != NULL __DBG_LINE);
BOOL ret = TRUE;
uint8_t ver_len = 0;
uint8_t msg_crc = 0, ver_crc = 0;
msg->state = data[1];
msg->dev_no = data[2];
msg->cmd_no = data[3];
msg->len = data[4];
osel_memcpy(msg->data, (uint8_t *)&data[5], msg->len);
}
// 发送数据编码
static void send_data_encode(frame_msg_t *msg)
{
uint16_t ver_len = 0, ver_crc = 0;
uint8_t *sp = (uint8_t *)send_buffer;
DBG_ASSERT(msg != NULL __DBG_LINE);
*sp++ = PACKET_STX; // 包头
ver_len++;
*sp++ = msg->state; // 状态
ver_len++;
*sp++ = msg->dev_no; // 设备号
ver_len++;
*sp++ = msg->cmd_no; // 命令号
ver_len++;
*sp++ = msg->len; // 长度
ver_len++;
osel_memcpy(sp, msg->data, msg->len); // 数据
sp += msg->len;
ver_len += msg->len;
ver_crc = crc16_compute((uint8_t *)&send_buffer[1], (ver_len - 1)); // 减去包头
ver_crc = S2B_UINT16(ver_crc);
osel_memcpy(sp, (uint8_t *)&ver_crc, 2); // 校验
sp += 2;
ver_len += 2;
*sp++ = PACKET_ETX; // 包尾
ver_len++;
// 发送
host_send_msg((uint8_t *)send_buffer, ver_len);
}
// 数据处理
void host_data_deal(void)
{
frame_msg_t *rx_msg = (frame_msg_t *)&rx_frame;
frame_msg_t *bk_msg = (frame_msg_t *)&bk_frame;
if (deal_done_flag == TRUE)
// 包头包尾检查
if (data[0] != PACKET_STX || data[1] != ST_DEV_NORMAL || data[len - 1] != PACKET_ETX)
{
return;
ret = FALSE;
return ret;
}
// 长度检查
ver_len = PACKET_MIN_LEN + data[DATA_LEN_INDEX];
if (ver_len != len)
{
ret = FALSE;
return ret;
}
// CRC校验
msg_crc = data[len - 2];
ver_crc = xor_compute((uint8_t *)&data[1], (len - 3)); // 减去包头、包尾、校验
if (msg_crc != ver_crc)
{
ret = FALSE;
return ret;
}
// 执行
return ret;
}
// 数据解码
static void host_data_decode(uint8_t *data, uint16_t len)
{
DBG_ASSERT(data != NULL __DBG_LINE);
// 获取数据长度和消息长度
uint8_t data_len = data[DATA_LEN_INDEX];
uint8_t msg_len = DATA_INDEX + data_len;
// 获取消息数据
osel_memcpy((uint8_t *)&rx_msg, data, msg_len);
}
// 指令执行
static void host_cmd_execute(frame_msg_t *rx_msg, frame_msg_t *bk_msg)
{
DBG_ASSERT(rx_msg != NULL __DBG_LINE);
DBG_ASSERT(bk_msg != NULL __DBG_LINE);
switch (rx_msg->dev_no)
{
case ADC_SENSOR:
@ -85,47 +76,54 @@ void host_data_deal(void)
motor_process(rx_msg, bk_msg);
break;
default:
return;
break;
}
// 回复（组包 + 发送）
send_data_encode(bk_msg);
// 修改标志位
deal_done_flag = TRUE;
osel_memset((uint8_t *)rx_msg, 0, sizeof(rx_frame));
osel_memset((uint8_t *)bk_msg, 0, sizeof(bk_frame));
}
// 数据完整性检查
static BOOL host_data_verify(uint8_t *data, uint16_t len)
// 数据编码
static void host_data_encode(frame_msg_t *msg)
{
BOOL ret = TRUE;
uint16_t ver_len = 0;
uint16_t ver_crc = 0, rx_crc = 0;
DBG_ASSERT(msg != NULL __DBG_LINE);
// 包头包尾检查
if (data[0] != PACKET_STX || data[1] != MASTER_CODE || data[len - 1] != PACKET_ETX)
uint8_t *pbuf = (uint8_t *)host_send_buffer;
uint8_t index = 0, len = 0;
// 消息数据
uint8_t msg_len = DATA_INDEX + msg->len;
osel_memcpy(pbuf, (uint8_t *)msg, msg_len);
// 校验码
index += msg_len;
pbuf[index] = xor_compute((uint8_t *)&pbuf[1], (msg_len - 1)); // 减去包头
// 包尾
index += 1;
pbuf[index] = PACKET_ETX;
// 计算报文长度
len = msg_len + 2; // 加上校验、包尾
// 发送
host_send_msg(pbuf, len);
}
// 数据处理
void host_rx_msg_deal(void)
{
if (execute_state == TRUE)
{
ret = FALSE;
return ret;
}
// 帧长度检查
ver_len = data[4] + PACKET_MIN_LEN;
if (ver_len != len)
{
ret = FALSE;
return ret;
}
// CRC校验
ver_crc = crc16_compute((uint8_t *)(data + 1), (len - 4)); // 减去包头、包尾、校验
ver_crc = S2B_UINT16(ver_crc);
osel_memcpy((uint8_t *)&rx_crc, (uint8_t *)(data + len - 3), 2);
if (ver_crc != rx_crc)
{
ret = FALSE;
return ret;
return;
}
return ret;
frame_msg_t *p_rx_msg = (frame_msg_t *)&rx_msg;
frame_msg_t *p_bk_msg = (frame_msg_t *)&bk_msg;
// 执行
host_cmd_execute(p_rx_msg, p_bk_msg);
// 回复（组包 + 发送）
host_data_encode(p_bk_msg);
// 复位
osel_memset((uint8_t *)host_send_buffer, 0, UART_TXSIZE);
osel_memset((uint8_t *)&rx_msg, 0, sizeof(frame_msg_t));
osel_memset((uint8_t *)&bk_msg, 0, sizeof(frame_msg_t));
execute_state = IDLE;
}
// 串口接收回调
@ -133,18 +131,18 @@ static void host_rx_cb(uint8_t uart_index, uint8_t *data, uint16_t len)
{
BOOL ret = FALSE;
// 数据完整性检查
// 数据有效性检查
ret = host_data_verify(data, len);
// 数据处理
if (ret == TRUE && deal_done_flag == TRUE)
// 数据解码
if (ret == TRUE && execute_state == IDLE)
{
host_data_decode(data, len, (frame_msg_t *)&rx_frame);
deal_done_flag = FALSE;
host_data_decode(data, len);
execute_state = BUSY;
}
}
// 串口初始化
void host_uart_init(void)
static void host_uart_init(void)
{
if (uarts[UART_NUM_1] == NULL)
{
@ -160,6 +158,7 @@ void host_uart_init(void)
/************************************* 电机 *************************************/
// 电机对象
motor_t *motor;
motor_ctrl_t *motor_param = NULL;
// 电机初始化
static void motor_init(void)
@ -176,29 +175,34 @@ static void motor_init(void)
motor->handle.step_motor.interface.init(motor, dir, en, MIN_STEP_ANGLE, TIM21, LL_TIM_CHANNEL_CH2);
}
void motor_process_init(void)
{
motor_param = (motor_ctrl_t *)osel_mem_alloc(sizeof(motor_ctrl_t));
DBG_ASSERT(motor_param != NULL __DBG_LINE);
osel_memset((uint8_t *)motor_param, 0, sizeof(motor_ctrl_t));
}
// 电机任务
void motor_process(frame_msg_t *rx, frame_msg_t *bk)
{
// BOOL ret = TRUE;
DBG_ASSERT(rx != NULL __DBG_LINE);
// step_motor_t *step_motor = &motor->handle.step_motor;
// uint8_t state = ST_DEV_NORMAL;
switch (rx->cmd_no)
{
case SET_MOTOR_SPEED: // 设置电机转速
break;
case SET_DRIVER_PULSE: // 设置驱动器脉冲
break;
case GET_MIN_STEP: // 获取最小步距
break;
case GET_MOTOR_STATE: // 获取电机运行状态
break;
case MOTOR_MOVE: // 运行电机
break;
case MOTOR_STOP: // 停止电机
break;
default:
break;
}
bk->dev_no = MOTOR;
bk->cmd_no = rx->cmd_no;
}
/************************************* ADc传感器 *************************************/
@ -209,33 +213,99 @@ adc_t adc1 = {
.dma_channel = LL_DMA_CHANNEL_1,
};
// 获取扭力值
static BOOL get_tors_value(frame_msg_t *bk)
// 扭力，单位：N·m
uint16_t get_torsion_adc(void)
{
uint16_t value = 0;
uint16_t adc = adc_get_result_average(IN13);
return adc;
}
bk->len = sizeof(uint16_t);
value = adc_get_result_average(IN13);
float32 torsion_detect(void)
{
float32 adc = 0.0, val = 0.0;
adc = get_torsion_adc();
val = adc / 4096 * 3000;
val = (val - 1500) / 101 / (1.934 * 3) * 10;
return val;
}
// 压力，单位：kPa
uint16_t get_pressure_adc(void)
{
uint16_t adc = adc_get_result_average(IN7);
return adc;
}
float32 pressure_detect(void)
{
float32 adc = 0.0, val = 0.0;
adc = get_pressure_adc();
val = adc / 4096 * 3000;
val = (val - 600) / (10 * 15) / 16 * 1000;
return val;
}
// 流量，单位：SLPM
uint16_t get_flow_adc(void)
{
uint16_t adc = adc_get_result_average(IN8);
return adc;
}
float32 flow_detect(void)
{
float32 adc = 0.0, val = 0.0;
adc = get_flow_adc();
val = adc / 4096 * 3000;
val = (val - 600) / (10 * 15) / 16 * 300;
return val;
}
// 获取扭力值
static void cmd_torsion_value(frame_msg_t *bk)
{
uint8_t state = ST_DEV_NORMAL;
// 计算数据长度
uint8_t data_len = sizeof(uint16_t);
// 采集
uint16_t value = get_torsion_adc();
// TODO 检查数据合法性
// 回复数据
bk->head = PACKET_STX;
bk->state = state;
bk->dev_no = ADC_SENSOR;
bk->cmd_no = GET_TORSION_VALUE;
bk->len = data_len;
value = S2B_UINT16(value);
osel_memcpy(bk->data, (uint8_t *)&value, bk->len);
return TRUE;
osel_memcpy((uint8_t *)bk->data, (uint8_t *)&value, data_len);
}
// 传感器任务
void sensor_procss(frame_msg_t *rx, frame_msg_t *bk)
{
BOOL ret = TRUE;
switch (rx->cmd_no)
{
case GET_TORS_VALUE: // 获取扭力值
ret = get_tors_value(bk);
case GET_TORSION_VALUE: // 获取扭力值
cmd_torsion_value(bk);
break;
case GET_PRESSURE_VALUE:
break;
case GET_FLOW_VALUE:
break;
case GET_ALL_VALUE:
break;
default:
break;
}
bk->state = ret;
bk->dev_no = ADC_SENSOR;
bk->cmd_no = rx->cmd_no;
}
/************************************* 板卡 *************************************/

41
User/board/board.h
View File

@ -9,15 +9,16 @@
#define UART_TXSIZE (240u) // 发送缓冲区 240个字节
// 包头 + 状态码 + 设备号 + 命令号 + 长度 + 数据 + 校验 + 包尾
// 1 1 1 1 1 0~128 2 1
// 1 1 1 1 1 0~128 1 1
#define PACKET_STX 0xff // 包头
#define PACKET_ETX 0x3c // 包尾
#define MASTER_CODE 0x00 // 状态码-主机
#define PACKET_
#define DATA_LEN_INDEX 4 // 数据长度偏移
#define DATA_INDEX 5 // 数据偏移
// 最大数据长度
#define DATA_MAX_LEN 128
// 最小帧长度：包头 + 状态码 + 设备号 + 命令号 + 长度 + 校验 + 包尾
#define PACKET_MIN_LEN 8
#define PACKET_MIN_LEN 7
// 最大帧长度
#define PACKET_MAX_LEN (DATA_MAX_LEN + PACKET_MIN_LEN)
@ -25,6 +26,12 @@
#define PULSE_REV 18000.0 // 每圈脉冲数（驱动器脉冲）
#define MIN_STEP_ANGLE (360 / PULSE_REV) // 最小步距
typedef enum
{
IDLE = 0, // 空闲
BUSY = 1, // 忙碌
} host_state_e;
typedef enum
{
ADC_SENSOR,
@ -44,7 +51,6 @@ typedef enum
typedef enum
{
SET_MOTOR_SPEED,
SET_DRIVER_PULSE,
GET_MIN_STEP,
GET_MOTOR_STATE,
MOTOR_MOVE,
@ -53,28 +59,43 @@ typedef enum
typedef enum
{
GET_TORS_VALUE,
GET_TORSION_VALUE,
GET_PRESSURE_VALUE,
GET_FLOW_VALUE,
GET_ALL_VALUE,
} sensor_cmd_e;
typedef enum
{
ST_DEV_NORMAL,
ST_DEV_BUSY,
ST_MSG_MISS,
ST_DEV_MISS,
} status_code_e;
typedef struct
{
uint8_t head; // 包头
uint8_t state; // 状态
uint8_t dev_no; // 设备号
uint8_t cmd_no; // 命令号
uint8_t len; // 长度
uint8_t data[DATA_MAX_LEN]; // 数据
} frame_msg_t;
extern void host_uart_init(void);
typedef struct
{
uint8_t dir;
float32 angle;
} motor_ctrl_t;
extern void board_init(void);
extern void host_data_deal(void);
extern uint16_t get_torsion_adc(void);
extern float32 torsion_detect(void);
extern uint16_t get_pressure_adc(void);
extern float32 pressure_detect(void);
extern uint16_t get_flow_adc(void);
extern float32 flow_detect(void);
extern void host_rx_msg_deal(void);
extern void motor_process_init(void);
#endif // __BOARD_H__

6
User/board/motor.c
View File

@ -60,6 +60,11 @@ static void step_motor_set_angle(motor_t *motor, uint32_t angle, dir_e dir)
}
}
static void step_motor_set_speed(motor_t *motor, uint32_t psc)
{
}
/**
* @brief 步进电机中断处理函数
* @param {motor_t} *motor
@ -103,6 +108,7 @@ motor_t *motor_create(motor_type_e motor_type)
motor->handle.step_motor.interface.run = step_motor_run;
motor->handle.step_motor.interface.stop = step_motor_stop;
motor->handle.step_motor.interface.set_angle = step_motor_set_angle;
motor->handle.step_motor.interface.set_speed = step_motor_set_speed;
break;
default:

2
User/board/motor.h
View File

@ -39,7 +39,7 @@ typedef struct
void (*stop)(motor_t *motor); // 停止
void (*set_angle)(motor_t *motor, uint32_t angle, dir_e dir); // 将角度转换成脉冲个数并运行
void (*stop_cb)(motor_t *motor); // 停止回调函数,在stop中执行
void (*set_speed)(motor_t *motor, uint32_t psc);
} step_motor_interface_t;
typedef struct