lora_bl/Core/Src/E52.c

//
// Created by EDZ on 25-9-11.
//

#include "../Inc/E52.h"

Device_structure deviceInfo;


void E52_CtlPowerOn_Fun() {
    HAL_GPIO_WritePin(POWER_ON_GPIO_Port, CTL_LORA_POWER_Pin, GPIO_PIN_RESET);
}

void E52_CtlPowerOff_Fun() {
    HAL_GPIO_WritePin(POWER_ON_GPIO_Port, CTL_LORA_POWER_Pin, GPIO_PIN_SET);
}


void E52_AT_TYPE_Fun(uint8_t type) {
    HAL_Delay(1000);
    char lora_msg[20];
    // 拼接字符串 AT+TYPE=x
    sprintf(lora_msg, "AT+TYPE=%d", type);

    HAL_UART_Transmit(&huart2, (uint8_t *)lora_msg, strlen(lora_msg), HAL_MAX_DELAY);
    HAL_Delay(1000);
}


//AT COMMAND
/**
 *配置lora发送方式
 *
 */

void E52_CONFIG_BROADCAST_TYPE_FUN(uint8_t type) {
    static const char *options[] = {
        [BROADCAST_ALL] = "AT+OPTION=3,0",
        [BROADCAST_MULTI] = "AT+OPTION=2,0",
        [BROADCAST_SINGLE] = "AT+OPTION=1,0",
    };

    if (type < BROADCAST_SINGLE || type > BROADCAST_ALL || options[type] == NULL) {
        return; // 参数非法
    }

    HAL_UART_Transmit(&huart2, (uint8_t *) options[type], strlen(options[type]), HAL_MAX_DELAY);
}

/*
 *
 * 配置单波与多播地址
 */
void E104_BT5005A_DST_ADDR_Fun(void) {
    // 假设 target_addr_H 和 target_addr_L 是 uint8_t
    uint16_t addr = ((uint16_t)deviceInfo.target_addr_H << 8) | deviceInfo.target_addr_L;

    char lora_msg4[32];
    sprintf(lora_msg4, "AT+DST_ADDR=%u,0", addr);   // 拼接十进制字符串

    HAL_UART_Transmit(&huart2, (uint8_t *)lora_msg4, strlen(lora_msg4), HAL_MAX_DELAY);
}

/**
 *
 *设备向后台发生数据
 * 帧头：55 AA
 */
void E52_Heartbeat_Fun() {
    printf("这是心跳包\r\n");
    Heartbeat_structure heartbeat_structure;

    heartbeat_structure.frame_header_H = 0x55;
    heartbeat_structure.frame_header_L = 0xAA;
    heartbeat_structure.function_code = 0x01;
    heartbeat_structure.badge_addr_high = deviceInfo.loraDeviceAddress_H;
    heartbeat_structure.badge_addr_low = deviceInfo.loraDeviceAddress_L;
    heartbeat_structure.broadcast_type = deviceInfo.broadcast_type;
    heartbeat_structure.target_addr_H = deviceInfo.target_addr_H;
    heartbeat_structure.target_addr_L = deviceInfo.target_addr_L;
    heartbeat_structure.frame_tail_H = 0xFF;
    heartbeat_structure.frame_tail_L = 0xEE;

    // printf("heartbeat size = %d\n", sizeof(heartbeat_structure));

    HAL_UART_Transmit(&huart2, (uint8_t *)&heartbeat_structure, sizeof(heartbeat_structure), HAL_MAX_DELAY);
    // TODO: command:01
}

void E52_Send_Bl_Data_Fun( uint8_t *sendData,  uint8_t finishData) {
    printf("这是发送蓝牙数据\r\n");
    SendBlData_structure sendBlData_structure;
    sendBlData_structure.frame_header_H = 0x55;
    sendBlData_structure.frame_header_L = 0xAA;
    sendBlData_structure.function_code = 0x02;
    sendBlData_structure.badge_addr_high = deviceInfo.loraDeviceAddress_H;
    sendBlData_structure.badge_addr_low = deviceInfo.loraDeviceAddress_L;
    memcpy(sendBlData_structure.bl_data, sendData, 8);
    if (sendBlData_structure.bl_data[0] == 0x00) { //如果蓝牙数据未空，信号强度改为FF。
        sendBlData_structure.bl_data[7] = 0xFF;
    }
    sendBlData_structure.finish_send = finishData;
    sendBlData_structure.frame_tail_H = 0xFF;
    sendBlData_structure.frame_tail_L = 0xEE;
    // printf("blData size = %d\n", sizeof(sendBlData_structure));


    // deviceInfo.loraSendSuccessFlag = 1;
    HAL_UART_Transmit(&huart2, (uint8_t *)&sendBlData_structure, sizeof(sendBlData_structure), HAL_MAX_DELAY);
    // TODO: command:02
}

void E52_Send_SOS_Fun( uint8_t *sendData,uint8_t finishData) {
    printf("这是发送SOS数据\r\n");
    SendSOS_structure SendSOS_structure;
    SendSOS_structure.frame_header_H = 0x55;
    SendSOS_structure.frame_header_L = 0xAA;
    SendSOS_structure.function_code = 0x04;
    SendSOS_structure.badge_addr_high = deviceInfo.loraDeviceAddress_H;
    SendSOS_structure.badge_addr_low = deviceInfo.loraDeviceAddress_L;
    // SendSOS_structure.SOS_data = 0x01; //暂定01
    memcpy(SendSOS_structure.bl_data, sendData, 8);
    SendSOS_structure.finish_send = finishData;
    SendSOS_structure.frame_tail_H = 0xFF;
    SendSOS_structure.frame_tail_L = 0xEE;
    // printf("blData size = %d\n", sizeof(SendSOS_structure));
    HAL_UART_Transmit(&huart2, (uint8_t *)&SendSOS_structure, sizeof(SendSOS_structure), HAL_MAX_DELAY);
    // TODO: command:04
}

/**
 *
 *后台向设备发送数据
 * 帧头：55 BB
 */
void E52_Request_Command_Fun() {
    printf("这是请求蓝牙数据的命令\r\n");
    deviceInfo.forwardBLAndLoraDataCount = 1;
    if (rx_buf_uart2[5] == 0x00) {
        //发送一条
        deviceInfo.forwardBLAndLoraDataCountMax = 1;
    }else {
        deviceInfo.forwardBLAndLoraDataCountMax = rx_buf_uart2[5];
    }

    // 修复运算符优先级警告，添加括号明确先执行位运算再比较
    if ((((uint16_t)rx_buf_uart2[6] << 8) | rx_buf_uart2[7]) != 0) {
        // 组合两个字节为16位的持续时间值
        deviceInfo.forwardBLAndLoraDataDuration = ((uint16_t)rx_buf_uart2[6] << 8) | rx_buf_uart2[7];
    } else {
        printf("扫描时间为0,默认500ms扫描时间\r\n");
        deviceInfo.forwardBLAndLoraDataDuration = 500;
    }
    // TODO: command:03 - 此处添加0x03命令的其他处理逻辑
}


void E52_Configuration_Fun() {
    printf("这是配置lora发送方式的命令\r\n");

    deviceInfo.target_addr_H = rx_buf_uart2[8];
    deviceInfo.target_addr_L = rx_buf_uart2[9];
    switch (rx_buf_uart2[5]) {
        case BROADCAST_ALL:
            deviceInfo.broadcast_type = BROADCAST_ALL;
        break;

        case BROADCAST_MULTI:
            deviceInfo.broadcast_type = BROADCAST_MULTI;
        break;

        case BROADCAST_SINGLE:
            deviceInfo.broadcast_type = BROADCAST_SINGLE;
        break;

        default:
            printf("无效的广播类型，请重新输入\r\n");
            deviceInfo.target_addr_H = 0xFF;
            deviceInfo.target_addr_L = 0xFF;
            deviceInfo.broadcast_type = BROADCAST_ALL;
        break;
    }
    // TODO: command:07
}

void E52_Send_Sleep_Fun() {
    printf("这是让设备睡眠的命令\r\n");

    // 解析睡眠时间 24小时秒数
    uint32_t sleep_seconds = ((uint32_t)rx_buf_uart2[5] << 16) |
                             ((uint32_t)rx_buf_uart2[6] << 8)  |
                             ((uint32_t)rx_buf_uart2[7]);

    if (sleep_seconds == 0 || sleep_seconds > 86399) {
        printf("睡眠时间无效, 使用默认3000ms\r\n");
        deviceInfo.rtc_wake_up_time = 3000;
    } else {
        deviceInfo.rtc_wake_up_time = sleep_seconds;
        printf("接收到睡眠时间: %lu 秒\r\n", sleep_seconds);
    }
    // TODO: command:05
}

void E52_Heartbeat_Fun1() {
    printf("这是让设备重新发送点卯命令\r\n");
    Heartbeat_structure heartbeat_structure;

    heartbeat_structure.frame_header_H = 0x55;
    heartbeat_structure.frame_header_L = 0xAA;
    heartbeat_structure.function_code = 0x01;
    heartbeat_structure.badge_addr_high = deviceInfo.loraDeviceAddress_H;
    heartbeat_structure.badge_addr_low = deviceInfo.loraDeviceAddress_L;
    heartbeat_structure.broadcast_type = deviceInfo.broadcast_type;
    heartbeat_structure.target_addr_H = deviceInfo.target_addr_H;
    heartbeat_structure.target_addr_L = deviceInfo.target_addr_L;
    heartbeat_structure.frame_tail_H = 0xFF;
    heartbeat_structure.frame_tail_L = 0xEE;
    HAL_UART_Transmit(&huart2, (uint8_t *)&heartbeat_structure, sizeof(heartbeat_structure), HAL_MAX_DELAY);
    // TODO: command:08
}

void Enter_Sleep_ACK_Fun() {
    printf("这是心跳包\r\n");
    Heartbeat_structure heartbeat_structure;

    heartbeat_structure.frame_header_H = 0x55;
    heartbeat_structure.frame_header_L = 0xAA;
    heartbeat_structure.function_code = 0x05;
    heartbeat_structure.badge_addr_high = deviceInfo.loraDeviceAddress_H;
    heartbeat_structure.badge_addr_low = deviceInfo.loraDeviceAddress_L;
    heartbeat_structure.broadcast_type = deviceInfo.broadcast_type;
    heartbeat_structure.target_addr_H = deviceInfo.target_addr_H;
    heartbeat_structure.target_addr_L = deviceInfo.target_addr_L;
    heartbeat_structure.frame_tail_H = 0xFF;
    heartbeat_structure.frame_tail_L = 0xEE;

    HAL_UART_Transmit(&huart2, (uint8_t *)&heartbeat_structure, sizeof(heartbeat_structure), HAL_MAX_DELAY);
    // TODO: command:01
}

void E52_Analyze_Data() {
    // 根据接收到的第三个字节（命令字节）进行分支处理

    switch (rx_buf_uart2[2]) {
        case REQUEST_BLUETOOTH_DATA:
            E52_Request_Command_Fun();
            deviceInfo.commandFromCloud = COMBINE_CMD_STEP(REQUEST_BLUETOOTH_DATA, REQUEST_BLUETOOTH_DATA_SCAN);
            break;
        case CONFIGURE_E52:
            E52_Configuration_Fun();
            deviceInfo.commandFromCloud = COMBINE_CMD_STEP(CONFIGURE_E52, CONFIGURE_E52_SET_BROADCAST_TYPE);
            break;
        case E52_ENTER_SLEEP:
            E52_Send_Sleep_Fun();
            deviceInfo.commandFromCloud = COMBINE_CMD_STEP(E52_ENTER_SLEEP, RTC_SLEEP_STEP);
            break;
        case E52_HEARTBEAT:// 完成
            E52_Heartbeat_Fun1();
            deviceInfo.commandFromCloud = COMBINE_CMD_STEP(E52_HEARTBEAT, HEARTBEAT_SEND);
            break;
        case IS_ONLINE: //完成
            deviceInfo.isOnline = TRUE;
            deviceInfo.commandFromCloud = COMBINE_CMD_STEP(IDLE, STEP_INIT);
            break;
        default:
            deviceInfo.commandFromCloud = COMBINE_CMD_STEP(IDLE, STEP_INIT);
            break;
    }
}

void schedule_Fun() {

    if (deviceInfo.isOnline) {

    }

    if (GET_CMD(deviceInfo.commandFromCloud) == IDLE && GET_STEP(deviceInfo.commandFromCloud) == STEP_INIT) {

    }
    uint8_t command[DATA_SIZE];
    // 先出队一个数据腾出空间
    if (RingBuffer_Dequeue(&deviceInfo.queueBLData, command) == 0) {
        E52_Analyze_Data();
    }else {
        //如果队列为空，则进入初始化状态
        deviceInfo.commandFromCloud = COMBINE_CMD_STEP(IDLE, STEP_INIT);
    }
}