Wells_RTthread/app_wells_0407/workspace1/wells/applications/main.c

/*
 * Copyright (c) 2006-2024, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2024-03-04     RT-Thread    first version
 * 2024-07-04     LEI          V0704
 * 有人说：故事从这里开始
 * 故事像是那遥远的村庄，你从那里走来

 */

#include <rtthread.h>

#define DBG_TAG "main"
#define DBG_LVL DBG_LOG
#include <rtdbg.h>

#include "app_user.h"

//临时变量
extern rtc_control_t rtc_ctl;
extern iot_device_set_message_t i_set_mess;
extern rt_mailbox_t  iot_mb_ctl;
dev_power_t dev_power = {0};



/*
 * 主控主函数
 *
 */
int main(void)
{


    //RTT
    rtt_init();

    bsp_init_sleep();

    //系统初始化
    MX_GPIO_Init();

    //上电开启
    MX_DMA_Init();
    MX_ADC_Init();

    MX_USART1_UART_Init();
    MX_USART5_UART_Init();
    MX_USART4_UART_Init();

    MX_RTC_Init();

#if USER_WDT_ON
    MX_IWDG_Init();
#endif

    //打开LED
    DEV_LED_ON;

    //电源初始关闭
    GPS_PWR_OFF;
    NET_PWR_OFF;
    ADC_POWER_OFF;
    DEV_POWER_1_OFF;
    DEV_POWER_2_OFF;
    DEV_POWER_3_OFF;

    rt_thread_mdelay(1000);

    app_iwdg_refresh();

    //存储区数据
    mcu_eeprom_power();

    //设备扫描
    LOG_OUT("start_device_scan\r\n");
    app_device_scan();
    rt_thread_mdelay(1000);

    //传感器控制开启
    app_sensor_init();
    rt_thread_mdelay(1000);

    app_iwdg_refresh();

    //NB上电
    iot_ctl.i_run_ste = I_WORK;
    bsp_iot_power_init();
    app_iwdg_refresh();
    bsp_iot_close();

    app_iwdg_refresh();

    //蓝牙id+设备id
    ble_id_init();
    rt_thread_mdelay(1000);

    //开启蓝牙电源
    LOG_OUT("ble_reset wait\r\n");
    ble_ctl.b_init_flag = false;
    bsp_uart5_irq_on();

    for(uint8_t t=0; t<10; t++)
    {
        ble_ctl.b_run_ste = B_POWERON;
        bsp_ble_reset();
        rt_thread_mdelay(10000);

        if(ble_ctl.b_init_flag == true)
        {
            break;
        }

        app_iwdg_refresh();
    }

    app_iwdg_refresh();

    //开启GPS电源
//    LOG_OUT("gps_reset wait\r\n");
    gps_init_cmd();
    rt_thread_mdelay(1000);


    //设置距离传感器
//    LOG_OUT("distance_reset wait\r\n");
    bsp_distance_signal();
    rt_thread_mdelay(1000);

    app_iwdg_refresh();

    //等待蓝牙就绪进入休眠
    uart_send_u5((rt_uint8_t *)"AT+PWRM0\r\n",10);
    rt_thread_mdelay(50);
    uart_send_u5((rt_uint8_t *)"AT+PWRM0\r\n",10);
    rt_thread_mdelay(500);
    ble_ctl.b_run_ste = B_WORK;

    //模式
    dev_power.host_sleep_m = m_sleep;
    dev_power.ble_sleep_m = m_sleep;
    dev_power.wakeup_state = w_idle;

    //默认配置
    iot_device_default();

    app_iwdg_refresh();

    at24c512_init(NULL);
    ota_ctl_thread_init();

    app_iwdg_refresh();


    for(uint8_t t=0; t<10; t++)
    {
        DEV_LED_TOG;
        rt_thread_mdelay(200);
    }
    //LED关闭
    DEV_LED_OFF;

    //if(boot_read_version() == true)
    {
        //上电先上传一次，确定版本号
        LOG_OUT("power work\r\n");
        rtc_ctl.iot_up_count = rtc_ctl.iot_up_value;
    }

    app_iwdg_refresh();
    LOG_OUT("ALL INIT OK\r\n");
    rt_thread_mdelay(1000);

    while (1)
    {
        //主控
        LOG_OUT("co %d<%d %d\r\n", rtc_ctl.collect_count, rtc_ctl.collect_value, i_set_mess.collect_period);
        LOG_OUT("up %d<%d %d\r\n", rtc_ctl.iot_up_count, rtc_ctl.iot_up_value, i_set_mess.up_period);
        LOG_OUT("sl %d+%d\r\n",dev_power.host_sleep_m, dev_power.ble_sleep_m);
        //等待
        //rt_thread_mdelay(2);

        //触发采集
        if(dev_power.wakeup_state > w_idle)
        {
            LOG_OUT("wakeup_state=%d\r\n", dev_power.wakeup_state);
            if(dev_power.wakeup_state == w_lid && i_set_mess.activate == true)
            {
                dev_power.host_sleep_m = m_work;
                rt_mb_send_wait(iot_mb_ctl, I_EVT_RTC, 1000);
            }
            dev_power.wakeup_state = w_idle;
            //等待蓝牙数据
            rt_thread_mdelay(5000);
            app_iwdg_refresh();
        }
        //功耗模式
        if(  dev_power.host_sleep_m == m_sleep && dev_power.ble_sleep_m == m_sleep)
        {
            //重复关闭电源
            GPS_PWR_OFF;
            NET_PWR_OFF;
            ADC_POWER_OFF;
            DEV_POWER_1_OFF;
            DEV_POWER_2_OFF;
            DEV_POWER_3_OFF;

            bsp_enter_sleep();
        }
        else
        {
            //打开
            DEV_LED_ON;
            rt_thread_mdelay(100);
            //关闭
            DEV_LED_OFF;

            for(uint8_t t=0; t<4; t++)
            {
                app_iwdg_refresh();
                rt_thread_mdelay(5000);

                if(  dev_power.host_sleep_m == m_sleep && dev_power.ble_sleep_m == m_sleep)
                {
                    LOG_OUT("ready sleep\r\n");
                    break;
                }
            }
        }

        app_iwdg_refresh();
    }

    return RT_EOK;
}



static int object_name_maxlen(const char *type_name, struct rt_list_node *list)
{
    struct rt_list_node *node;
    struct rt_object *object = NULL;
    int max_length = rt_strlen(type_name), length;

    rt_enter_critical();
    for (node = list->next; node != list; node = node->next)
    {
        object = rt_list_entry(node, struct rt_object, list);

        length = rt_strlen(object->name);
        if (length > max_length) max_length = length;
    }
    rt_exit_critical();

    if (max_length > RT_NAME_MAX || max_length == 0) max_length = RT_NAME_MAX;

    return max_length;
}
rt_inline void object_split(int len)
{
    while (len--) LOG_OUT("-");
}
static long u_list_thread(struct rt_list_node *list)
{
    int maxlen;
    rt_uint8_t *ptr;
    struct rt_thread *thread;
    struct rt_list_node *node;
    const char *item_title = "thread";

    maxlen = object_name_maxlen(item_title, list);

    LOG_OUT("%d %s \n", maxlen, item_title);
    //object_split(maxlen);
    LOG_OUT("--- --- --- --- ---\n");
    for (node = list->next; node != list; node = node->next)
    {
        rt_uint8_t stat;
        thread = rt_list_entry(node, struct rt_thread, list);
        LOG_OUT("%d %d %8s %3d ", maxlen, RT_NAME_MAX, thread->name, thread->current_priority);

        stat = (thread->stat & RT_THREAD_STAT_MASK);
        if (stat == RT_THREAD_READY)        LOG_OUT("ready  ");
        else if (stat == RT_THREAD_SUSPEND) LOG_OUT("suspend");
        else if (stat == RT_THREAD_INIT)    LOG_OUT("init   ");
        else if (stat == RT_THREAD_CLOSE)   LOG_OUT("close  ");

        ptr = (rt_uint8_t *)thread->stack_addr;
        while (*ptr == '#')ptr ++;

        LOG_OUT(" %x %04x %d%%  %x %d\n",
                   thread->stack_size + ((rt_uint32_t)thread->stack_addr - (rt_uint32_t)thread->sp),
                   thread->stack_size,
                   (thread->stack_size - ((rt_uint32_t) ptr - (rt_uint32_t) thread->stack_addr)) * 100
                        / thread->stack_size,
                   thread->remaining_tick,
                   thread->error);
    }

    return 0;
}
long user_list_thread(void)
{
    struct rt_object_information *info;

    info = rt_object_get_information(RT_Object_Class_Thread);
    return u_list_thread(&info->object_list);
}

void rtthread_info_logout(void)
{
    rt_uint32_t total_num = 0;
    rt_uint32_t used_num = 0;
    rt_uint32_t max_used_num = 0;

    rt_memory_info(&total_num, &used_num, &max_used_num);
    LOG_OUT("total=%d ", total_num);
    LOG_OUT("used=%d ", used_num);
    LOG_OUT("max_used=%d\r\n", max_used_num);
    //三个数<E4B8AA>?<3F>分别是总空间，当前占用空间，历史最大占用空<E794A8>?????????????????
    user_list_thread();
}

/*
 * 中断向量表映射
 */
void jump_app_init(void)
{
    //APP地址：16*1024 = 16384 = 0X4000
    #define  RUN_APP_ADDRESS   (0x4000)

    SCB->VTOR = FLASH_BASE | RUN_APP_ADDRESS;

    //开启中断
    __enable_irq();
}