【道生物联TKB-623评估板试用】3. 基于 STM32 与 TKB-623 的无线超声波测距系统设计与实现

一、项目目标

构建一个基于 STM32 + TKB-623 LoRa 模组的无线测距系统，实现从传感器采集 → 本地处理 → AT 指令无线透传 → 远程接收的完整闭环，并验证其可靠性与实用性。

项目重点验证以下能力：

• STM32 与 TKB-623 模组的串口通信与 AT 指令控制；
• 基于异步终端工作模式的点对点无线数据透传；
• 端到端的数据完整性与通信稳定性；
• 轻量级上位机（Python）对无线传感数据的接收与处理。

二、硬件与软件准备

硬件清单

1. TKB-623 开发板 × 2（板 A：数据转发端，板 B：数据接收端）

2. HC-SR04 超声波传感器 × 1（测距，本次项目的数据来源）

3. USB-TTL 模块 × 2、若干杜邦线、天线 × 2、5V 电源

4. STM32F103C8T6（用于采集数据）

   发送端（STM32F103连HC-SR04，STM32通过串口连TKB623，TKB623连电脑（通过电脑显示要发送的数据））
   

   接收端
   

软件工具

1. 串口助手（逐飞助手 / SSCOM）
2. Python 3.8+（pyserial库：pip install pyserial）

三、编写程序

步骤 1：STM32实现超声波测距 + 配置板 A透传模式

板A的配置：

AT+FREQ=473200000
AT+RATE=9
AT+ADDR=00:00:00:01
AT+DEST=00:00:00:02

之后输入 ```

AT+WORKMODE=81,3,100

进入透传模式（将板A收到的数据转发给B板）

STM32F103C8T6的关键代码如下。

main.c

#include "stm32f10x.h"                  // Device header
#include "usart.h"
#include "HCSR04.h"
#include "delay.h"
#include "timer.h"
#include <stdio.h>
#include <string.h>
char buf[128] = {0};



// 主函数：发送温湿度数据到 TKB623
void Send_To_TKB623(int data1, int data2) {
    char data_str[32];
    sprintf(data_str, "distances=%d.%d", data1, data2); 

    // 转为十六进制字符串（大写）
    char hex_str[64] = {0};
    for (int i = 0; i < strlen(data_str); i++) {
        sprintf(&hex_str[i*2], "%02X", (unsigned char)data_str[i]);
    }

    // 构造完整 AT 指令
    char at_cmd[80];
    sprintf(at_cmd, "AT+SENDB=%s\\r\\n", hex_str);

    // 通过 USART1 发送给 TKB623
    USART1_SendString(at_cmd);
}
int main(void)
{
	USART1_Config();
	USART2_Config();
	Timer_Config();
	HC_SR04_Config();
	sprintf(buf,"AT\\r\\n");
	USART1_SendString(buf);
	while(1)
	{
		int Distance_mm=sonar_mm();	//获取距离测量结果，单位毫米（mm）		
		int Distance_m=Distance_mm/1000;	//转换为米（m）为单位，将整数部分放入Distance_m
		int Distance_m_p=Distance_mm%1000;	//转换为米（m）为单位，将小数部分放入Distance_m_p
		Send_To_TKB623(Distance_m,Distance_m_p);
//		sprintf(buf,"AT+SENDB=23\\r\\n");
//		USART1_SendString(buf);
		delayms(1000);
	
	}
}

usart.c

#include "usart.h"

void USART1_Config()
{
	//声明结构体
	GPIO_InitTypeDef GPIO_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	
	//开时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE); // PA9和PA10要复用为Rx和Tx
	
	
	//GPIO_PinRemapConfig(GPIO_Remap_USART1,ENABLE);
	
	//配置PA9(Tx发送引脚)和PA10(Rx接收引脚)
	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_9;
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP;//复用推挽输出模式
	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
	GPIO_Init(GPIOA,&GPIO_InitStructure);
	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_10;
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IN_FLOATING;//浮空输入模式
	GPIO_Init(GPIOA,&GPIO_InitStructure);

	
	//配置串口
	USART_InitStructure.USART_BaudRate=115200;
	USART_InitStructure.USART_HardwareFlowControl=USART_HardwareFlowControl_None;
	USART_InitStructure.USART_Mode=USART_Mode_Rx | USART_Mode_Tx;//全双工
	USART_InitStructure.USART_Parity=USART_Parity_No;//不要校准
	USART_InitStructure.USART_StopBits=USART_StopBits_1;//一位停止位
	USART_InitStructure.USART_WordLength=USART_WordLength_8b;//字长为8bit
	USART_Init(USART1,&USART_InitStructure);
	
	//配置NVIC
	NVIC_InitStructure.NVIC_IRQChannel=USART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority=0;
	NVIC_Init(&NVIC_InitStructure);
	
	//配置中断源，接收到数据则触发中断
	USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);

	//使能USART1
	USART_Cmd(USART1,ENABLE);
	
	
}

void USART1_SendString(const char* str)
{

	while(*str)
	{
		USART_SendData(USART1,*str++);
		while(USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET);// 检查是否发送完成
	}

}

//中断服务函数
void USART1_IRQHandler()
{
	if(USART_GetITStatus(USART1,USART_IT_RXNE) == SET)
	{
		
		// 将接收到的数据发送回去
		USART_SendData(USART2,USART_ReceiveData(USART1));
		//清零中断标志位
		USART_ClearITPendingBit(USART1, USART_IT_RXNE);
		
		
		
	}
}

delayms.c

#include "delay.h"

void delayms(uint32_t t)
{
	for (int i=0;i<1000;i++){
		SysTick->CTRL = 0;//SysTick禁用
		SysTick->LOAD=9*t-1;// 装载值
		SysTick->VAL=0;//将当前值清零
		SysTick->CTRL=1;//0x...010 使用内部时钟，8MHz
		while((SysTick->CTRL & 0x00010000)==0);//等待数完
		SysTick->CTRL=0;//禁用SysTick
	}
	
}

HCSR04.c

#include "HCSR04.h"
#include "delay.h"

uint64_t time=0;			//声明变量，用来计时
uint64_t time_end=0;		//声明变量，存储回波信号时间

void HC_SR04_Config(void)
{
	RCC_APB2PeriphClockCmd(HCSR04_CLK,ENABLE);	
	GPIO_InitTypeDef GPIO_InitStructure;					
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;		
	GPIO_InitStructure.GPIO_Pin = HCSR04_TRIG_PIN;						
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;		
	GPIO_Init(HCSR04_PORT,&GPIO_InitStructure);	
	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;			//设置GPIO口为下拉输入模式
	GPIO_InitStructure.GPIO_Pin = HCSR04_ECHO_PIN;						//设置GPIO口6
	GPIO_Init(HCSR04_PORT,&GPIO_InitStructure);	
	//初始化GPIOB
	GPIO_WriteBit(HCSR04_PORT,HCSR04_TRIG_PIN,Bit_RESET);
	delayus(15);
}
uint16_t sonar_mm(void)
{
	uint32_t Distance,Distance_mm = 0;
	GPIO_WriteBit(HCSR04_PORT,HCSR04_TRIG_PIN,Bit_SET);//输出高电平
	delayus(15);
	GPIO_WriteBit(HCSR04_PORT,HCSR04_TRIG_PIN,Bit_RESET);//输出低电平
	while(GPIO_ReadInputDataBit(HCSR04_PORT,HCSR04_ECHO_PIN) == 0);//等待低电平结束
	time = 0;
	while(GPIO_ReadInputDataBit(HCSR04_PORT,HCSR04_ECHO_PIN)==1);		//等待高电平结束
	time_end = time;
	if(time_end/100 < 38)
	{
		Distance=(time_end*343) / 2;						//计算距离，25°C空气中的音速为346m/s
		Distance_mm=Distance/100;
	}
	// 限制有效测量范围（多数HC-SR04的有效范围是2cm-4m）
	if(Distance_mm < 20 || Distance_mm > 4000)
		return 0;
	delayms(50);
	return Distance_mm;		
	
}
float sonar(void)
{
	float result = sonar_mm();
	return result / 1000.0f;
}

void TIM3_IRQHandler(void)
{
	if (TIM_GetITStatus(TIM3, TIM_IT_Update) == SET)		//获取TIM3定时器的更新中断标志位
	{
		time++;
		TIM_ClearITPendingBit(TIM3, TIM_IT_Update);			//清除更新中断标志位
	}
}

省略Tim.c和其他头文件等文件。

步骤3：编写python脚本，通过PySerial将STM32的数据转发给A板（A板接收到数据后转发）

# stm32_to_tkb_forwarder.py
import serial
import time

# ====== 配置区（根据你的实际情况修改）======
STM32_COM = 'COM10'    # STM32 接的串口号
TKB_COM    = 'COM8'   # TKB623 接的串口号
BAUDRATE   = 115200   # 必须与 STM32 和 TKB623 的串口波特率一致
# ==========================================

def main():
    stm32_ser = None
    tkb_ser = None

    try:
        # 打开 STM32 串口（只读）
        stm32_ser = serial.Serial(STM32_COM, BAUDRATE, timeout=1)
        print(f"[✓] 已连接 STM32: {STM32_COM}")

        # 打开 TKB623 串口（只写）
        tkb_ser = serial.Serial(TKB_COM, BAUDRATE, timeout=1)
        print(f"[✓] 已连接 TKB623: {TKB_COM}")

        print("[INFO] 开始转发：STM32 → TKB623（透传）")
        print("按 Ctrl+C 退出...")

        while True:
            if stm32_ser.in_waiting > 0:
                data = stm32_ser.read(stm32_ser.in_waiting)
                # 打印原始字节（十六进制 + ASCII 尝试）
                try:
                    text = data.decode('utf-8', errors='replace')
                    print(f"[RX] 原始: {data.hex()} | 文本: {repr(text)}")
                except:
                    print(f"[RX] 原始: {data.hex()}")

                # 转发给 TKB623（透传模式下会无线发出）
                tkb_ser.write(data)
                tkb_ser.flush()

            time.sleep(0.01)

    except KeyboardInterrupt:
        print("\n[!] 用户中断退出")
    except Exception as e:
        print(f"[ERROR] {e}")
    finally:
        if stm32_ser and stm32_ser.is_open:
            stm32_ser.close()
        if tkb_ser and tkb_ser.is_open:
            tkb_ser.close()
        print("[✓] 串口已关闭")

if __name__ == '__main__':
    main()

步骤3：配置板B，显示板B接收板A传来的数据

AT+FREQ=473200000
AT+RATE=9
AT+ADDR=00:00:00:02

再通过串口助手显示。

表示远程接收端板B已接收到数据。