智能烧水壶 (Bluetooth版)03——离线控制功能实现篇

最新推荐文章于 2024-04-14 20:16:36 发布
最新推荐文章于 2024-04-14 20:16:36 发布
阅读量720 收藏 3
点赞数 2
分类专栏： # 智能烧水壶 文章标签： 智能烧水壶 物联网 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sandwich_iot/article/details/119042152
版权
前言常见的烧水壶一般有煮沸、保温功能，本案例在此基础上，使用涂鸦BLE SDK和BLE模组实现了对烧水壶的远程控制，包括保温温度设置、水质模式选择、预约烧水等功能，另外还增加了干烧报警等功能，使烧水壶更加智能化。完整Demo可在 tuya-iotos-embeded-demo-ble-smart-kettle 中获取。功能设定本案例中的智能烧水壶设备上提供煮沸、保温2个按键，以及3个指示灯和1个蜂鸣器用于状态提示，可以本地控制也可以远程控制，具体功能设定如下：功能说明煮沸轻触
摘要由CSDN通过智能技术生成

前言

常见的烧水壶一般有煮沸、保温功能，本案例在此基础上，使用涂鸦BLE SDK和BLE模组实现了对烧水壶的远程控制，包括保温温度设置、水质模式选择、预约烧水等功能，另外还增加了干烧报警等功能，使烧水壶更加智能化。

完整Demo可在 tuya-iotos-embeded-demo-ble-smart-kettle 中获取。

功能设定

本案例中的智能烧水壶设备上提供煮沸、保温2个按键，以及3个指示灯和1个蜂鸣器用于状态提示，可以本地控制也可以远程控制，具体功能设定如下：

功能说明
煮沸轻触煮沸键，蜂鸣器“滴”一声提醒，切换煮沸功能开/关；
煮沸功能打开时，红灯亮，加热打开直至达到煮沸温度；
煮沸功能关闭或煮沸完成时，红灯灭，加热关闭；
保温轻触保温键，蜂鸣器“滴”一声提醒，切换保温功能开/关；
保温功能打开且未达到保温温度时，橙灯亮，绿灯灭，加热根据当前温度打开或关闭；
保温功能关闭或达到保温温度时，橙灯灭，绿灯亮，加热关闭；
用水类型为自来水时，先加热至煮沸再保温至保温温度；
用水类型为纯净水时，直接加热至保温温度；
保温温度默认为55℃，可通过APP设置，设置范围在45-90℃；
用水类型默认为自来水，可通过APP设置；
干烧报警检测到干烧后自动关闭加热，硬件断电，蜂鸣器长鸣报警；
配网上电配网，3分钟后未配网成功，仅可本地控制；
长按保温键5秒进入配网状态，3分钟后未配网成功，仅可本地控制；
等待配网时，绿灯快闪；
远程控制可通过APP操作的项目有：打开/关闭煮沸功能和保温功能、设置保温温度和用水类型、查看当前温度和故障状态、预约烧水时间；

后面我们会一一介绍实现上述功能的具体方案和过程。

离线控制功能实现

（1）指示灯驱动控制

指示灯作为烧水壶状态指示和配网指示，驱动形式为电平驱动，基本设置如下：

指示灯管脚HL显示模式
红色 P_LED_REDP24/GPIO_PB5灭亮固定(常亮/常灭)
橙色 P_LED_ORANGEP26/GPIO_PB4灭亮固定(常亮/常灭)
绿色 P_GREENP6/GPIO_PD2灭亮固定(常亮/常灭) / 闪烁(0.2s亮0.2s灭)

代码实现：

#define P_LED_RED           GPIO_PB5    /* P24 */
#define P_LED_ORANGE        GPIO_PB4    /* P26 */
#define P_LED_GREEN         GPIO_PD2    /* P6 */
#define LED_TWINKLE_TIME	200			/* 0.2s */

LED_MODE_E g_led_green_mode = LED_MODE_FIX;
LED_MODE_E g_led_green_status = OFF;

/* LED端口初始化 */
void led_init(void)
{
	gpio_set_func(P_LED_RED, AS_GPIO);
    gpio_set_output_en(P_LED_RED, 1);
    gpio_write(P_LED_RED, 1);
    gpio_set_func(P_LED_ORANGE, AS_GPIO);
    gpio_set_output_en(P_LED_ORANGE, 1);
    gpio_write(P_LED_ORANGE, 1);
    gpio_set_output_en(P_LED_GREEN, 1);
	gpio_set_func(P_LED_GREEN, AS_GPIO);
    gpio_write(P_LED_GREEN, 1);
}

/* 红色LED亮灭控制 */
void set_led_red(bool b_on_off)
{
    static bool s_last_status = 0;
    if (s_last_status != b_on_off) {
        if (b_on_off == ON) {
        	gpio_write(P_LED_RED, 0);
        } else {
        	gpio_write(P_LED_RED, 1);
        }
        s_last_status = b_on_off;
    }
}

/* 橙色LED亮灭控制 */
void set_led_orange(bool b_on_off)
{
    static bool s_last_status = 0;
    if (s_last_status != b_on_off) {
        if (b_on_off == ON) {
        	gpio_write(P_LED_ORANGE, 0);
        } else {
        	gpio_write(P_LED_ORANGE, 1);
        }
        s_last_status = b_on_off;
    }
}

/* 绿色LED亮灭控制 */
void set_led_green(bool b_on_off)
{
    static bool s_last_status = 0;

    if (s_last_status != b_on_off) {
        if (b_on_off == ON) {
        	gpio_write(P_LED_GREEN, 0);
        } else {
        	gpio_write(P_LED_GREEN, 1);
        }
        s_last_status = b_on_off;
    }
}

/* 绿色LED模式设置 */
void set_led_green_mode(LED_MODE_E mode)
{
    g_led_green_mode = mode;
}

/* 绿色LED状态设置 */
void set_led_green_status(uint8_t status)
{
    g_led_green_status = status;
}

/* 绿色LED状态更新 */
void update_led_green_status(void)
{
    static bool s_status = 0;
    static uint32_t s_twinkle_tm = 0;

    switch (g_led_green_mode) {
    case LED_MODE_FIX:      /* 固定模式：根据状态设置控制LED亮灭 */
        set_led_green(g_led_green_status);
        s_twinkle_tm = 0;
        break;
    case LED_MODE_TWINKLE:  /* 闪烁模式：0.2s翻转一次亮灭状态 */
        if (!clock_time_exceed(s_twinkle_tm, LED_TWINKLE_TIME*1000)) {
            break;
        }
        s_twinkle_tm = clock_time();
        s_status = !s_status;
        set_led_green(s_status);
        break;
    default:
        break;
    }
}
（2）继电器驱动控制

继电器的通断用于控制加热电路，驱动形式为电平驱动，基本设置如下：

继电器管脚HL
继电器 P_RELAYP14/GPIO_PD3打开加热关闭加热

代码实现：

#define P_RELAY	GPIO_PD3    /* P14 */

/* 继电器端口初始化 */
void relay_init(void)
{
	gpio_set_func(P_RELAY, AS_GPIO);
	gpio_set_output_en(P_RELAY, 1);
	gpio_write(P_RELAY, 0);
}

/* 继电器通断控制 */
void set_relay(bool b_on_off)
{
    static bool s_last_status = 0;
    if (s_last_status != b_on_off) {
        if (b_on_off == ON) {
        	gpio_write(P_RELAY, 1);
        } else {
        	gpio_write(P_RELAY, 0);
        }
        s_last_status = b_on_off;
    }
}
（3）蜂鸣器驱动控制

蜂鸣器作为按键提示音和故障报警提示音，驱动形式为方波信号驱动，基本设置如下：

蜂鸣器管脚模式方波信号(PWM)
蜂鸣器 P_BUZZERP17/GPIO_PD4停止 / 滴一声(70ms) / 故障(长鸣)通道：PWM2
周期：500us (2KHz)
占空比：50%

代码实现：

#define P_BUZZER            GPIO_PD4    /* P17 */
#define PWM_ID_BUZZER       PWM2_ID		/* PWM2 */
#define BUZZER_ONCE_TIME    70			/* 70ms */

typedef BYTE_T BUZZER_MODE_E; 
#define BUZZER_MODE_STOP    0x00		/* 停止 */
#define BUZZER_MODE_ONCE    0x01		/* 滴一声 */
#define BUZZER_MODE_FAULT   0x02		/* 故障 */

static uint8_t sg_buzzer_timer = OFF;
static uint32_t sg_buzzer_tm = 0;

/* 蜂鸣器端口及PWM配置初始化 */
void buzzer_pwm_init(void)
{
    pwm_set_clk(CLOCK_SYS_CLOCK_HZ, CLOCK_SYS_CLOCK_HZ);
	gpio_set_func(P_BUZZER, AS_PWM2_N);
    pwm_set_mode(PWM_ID_BUZZER, PWM_NORMAL_MODE);
    pwm_set_cycle_and_duty(PWM_ID_BUZZER, (uint16_t)(500 * CLOCK_SYS_CLOCK_1US), (uint16_t)(250 * CLOCK_SYS_CLOCK_1US));    /* 500us 2KHz 50% */
    gpio_write(P_BUZZER, 0);
}

/* 蜂鸣器开关控制 */
static void set_buzzer(bool b_on_off)
{
    static bool s_last_status = 0;
    if (s_last_status != b_on_off) {
        if (b_on_off == ON) {
        	pwm_start(PWM_ID_BUZZER);
        } else {
        	pwm_stop(PWM_ID_BUZZER);
            gpio_write(P_BUZZER, 0);
        }
        s_last_status = b_on_off;
    }
}

/* 蜂鸣器模式控制 */
void set_buzzer_mode(BUZZER_MODE_E mode)
{
    switch (mode) {
    case BUZZER_MODE_STOP:
        set_buzzer(OFF);
        break;
    case BUZZER_MODE_ONCE:
        set_buzzer(ON);
        sg_buzzer_timer = ON;
        sg_buzzer_tm = clock_time();
        break;
    case BUZZER_MODE_FAULT:
        set_buzzer(ON);
        break;
    default:
        break;
    }
}

/* 蜂鸣器状态更新 */
void update_buzzer_status(void)
{
    if (sg_buzzer_timer == ON) {
        if (!clock_time_exceed(sg_buzzer_tm, BUZZER_ONCE_TIME*1000)) {
            return;
        }
        set_buzzer(OFF);
        sg_buzzer_timer = OFF;
    }
}
（4）按键检测与处理

为了后期的程序扩展，采用注册回调函数的方式实现按键检测与处理。

代码实现：

a. 按键注册信息及初始化

用户可注册内容设定如下：

typedef void(* KEY_CALLBACK)();
typedef struct {
    uint16_t key1_pin;                  /* 按键1所用I/O口 */
    uint16_t key2_pin;                  /* 按键2所用I/O口 */
    KEY_CALLBACK key1_short_press_cb;   /* 按键1短按触发的回调函数 */
    KEY_CALLBACK key2_short_press_cb;   /* 按键2短按触发的回调函数 */
    KEY_CALLBACK key1_long_press_cb;    /* 按键1长按触发的回调函数 */
    KEY_CALLBACK key2_long_press_cb;    /* 按键2长按触发的回调函数 */
    uint32_t key1_long_press_time;      /* 按键1长按时间设置(ms) */
    uint32_t key2_long_press_time;      /* 按键2长按时间设置(ms) */
    uint32_t scan_time;                 /* 按键1扫描间隔设置(ms) */
} TS02N_KEY_DEF_T;

接下来定义按键检测所需的状态变量，和用户注册内容共同管理，然后编写按键初始化函数：

/* 按键状态 */
typedef struct {
    uint8_t cur_code;
    uint8_t prv_code;
    uint32_t cur_time;
    uint32_t prv_time;
} TS02N_KEY_STATUS_T;

/* 按键管理 */
typedef struct {
    TS02N_KEY_DEF_T* ts02n_key_def_s;
    TS02N_KEY_STATUS_T ts02n_key_status_s;
} TS02N_KEY_MANAGE_T;
static TS02N_KEY_MANAGE_T *sg_key_mag = NULL; 

/* 按键初始化 */
uint8_t ts02n_key_init(TS02N_KEY_DEF_T* key_def)
{
    /* 按键信息初始化 */
    sg_key_mag = (TS02N_KEY_MANAGE_T *)tuya_ble_malloc(sizeof(TS02N_KEY_MANAGE_T));
    memset(sg_key_mag, 0, sizeof(TS02N_KEY_MANAGE_T));
    sg_key_mag->ts02n_key_def_s = key_def;
    /* 回调函数检查 */
    if ((key_def->key1_short_press_cb == NULL) &&
    	(key_def->key2_short_press_cb == NULL) &&
        (key_def->key1_long_press_cb == NULL)  &&
        (key_def->key2_long_press_cb == NULL)) {
        tuya_ble_free((uint8_t *)sg_key_mag);
        return KEY_INIT_ERR;
    }

    /* 端口初始化 */
    gpio_set_func(key_def->key1_pin, AS_GPIO);
    gpio_set_input_en(key_def->key1_pin, 1);
    gpio_setup_up_down_resistor(key_def->key1_pin, PM_PIN_PULLUP_10K);
    gpio_set_func(key_def->key2_pin, AS_GPIO);
    gpio_set_input_en(key_def->key2_pin, 1);
    gpio_setup_up_down_resistor(key_def->key2_pin, PM_PIN_PULLUP_10K);

    return KEY_INIT_OK;
}

b. 按键扫描及判断处理

首先分别定义按键1和按键2的键值以及短按确认时间：

#define KEY1_CODE				0x01
#define KEY2_CODE				0x02
#define KEY_PRESS_SHORT_TIME    50

然后编写定时循环的按键状态扫描函数和按键处理函数：

/* 获取当前键值 */
static uint8_t get_key_code(void)
{
    uint8_t key_code = 0;
    /* 按键1 */
    if (gpio_read(sg_key_mag->ts02n_key_def_s->key1_pin) == 0) {
        key_code |= KEY1_CODE;
    } else {
        key_code &= ~KEY1_CODE;
    }
    /* 按键2 */
    if (gpio_read(sg_key_mag->ts02n_key_def_s->key2_pin) == 0) {
        key_code |= KEY2_CODE;
    } else {
        key_code &= ~KEY2_CODE;
    }
    return key_code;
}

/* 扫描按键状态 */
static void update_key_status(uint32_t time_inc)
{
    uint8_t key_code;

    key_code = get_key_code();
    sg_key_mag->ts02n_key_status_s.prv_time = sg_key_mag->ts02n_key_status_s.cur_time;
    sg_key_mag->ts02n_key_status_s.cur_time += time_inc;

    if (key_code != sg_key_mag->ts02n_key_status_s.cur_code) {
        sg_key_mag->ts02n_key_status_s.prv_code = sg_key_mag->ts02n_key_status_s.cur_code;
        sg_key_mag->ts02n_key_status_s.cur_code = key_code;
        sg_key_mag->ts02n_key_status_s.prv_time = sg_key_mag->ts02n_key_status_s.cur_time;
        sg_key_mag->ts02n_key_status_s.cur_time = 0;
    } else {
        sg_key_mag->ts02n_key_status_s.prv_code = sg_key_mag->ts02n_key_status_s.cur_code;
    }
}

/* 判断[key_code]按键按压时间是否超过[press_time] */
static uint8_t is_key_press_over_time(uint8_t key_code, uint32_t press_time)
{
    if (sg_key_mag->ts02n_key_status_s.cur_code == key_code) {
        if ((sg_key_mag->ts02n_key_status_s.cur_time >= press_time) &&
            (sg_key_mag->ts02n_key_status_s.prv_time < press_time)) {
            return 1;
        }
    }
    return 0;
}

/* 判断[key_code]按键释放时按压时间是否少于[press_time] */
static uint8_t is_key_release_to_release_less_time(uint8_t key_code, uint32_t press_time)
{
    if ((sg_key_mag->ts02n_key_status_s.prv_code == key_code) &&
        (sg_key_mag->ts02n_key_status_s.cur_code != key_code)) {
        if ((sg_key_mag->ts02n_key_status_s.prv_time >= KEY_PRESS_SHORT_TIME) &&
            (sg_key_mag->ts02n_key_status_s.prv_time < press_time)) {
            return 1;
        }
    }
    return 0;
}

/* 检测与处理按键事件 */
static void detect_and_handle_key_event(void)
{
    /* 按键1处理 */
    if (sg_key_mag->ts02n_key_def_s->key1_long_press_cb != NULL) {
        /* 长按 */
        if (is_key_press_over_time(KEY1_CODE, sg_key_mag->ts02n_key_def_s->key1_long_press_time)) {
            sg_key_mag->ts02n_key_def_s->key1_long_press_cb();
            TUYA_APP_LOG_DEBUG("key1 is long pressed");
        }
        /* 短按 */
        if (sg_key_mag->ts02n_key_def_s->key1_short_press_cb != NULL) {
            if (is_key_release_to_release_less_time(KEY1_CODE, sg_key_mag->ts02n_key_def_s->key1_long_press_time)) {
                sg_key_mag->ts02n_key_def_s->key1_short_press_cb();
                TUYA_APP_LOG_DEBUG("key1 is pressed");
            }
        }
    } else {
        /* 短按 */
        if (sg_key_mag->ts02n_key_def_s->key1_short_press_cb != NULL) {
            if (is_key_press_over_time(KEY1_CODE, KEY_PRESS_SHORT_TIME)) {
                sg_key_mag->ts02n_key_def_s->key1_short_press_cb();
                TUYA_APP_LOG_DEBUG("key1 is pressed");
            }
        }
    }
    /* 按键2处理 */
    if (sg_key_mag->ts02n_key_def_s->key2_long_press_cb != NULL) {
        /* 长按 */
        if (is_key_press_over_time(KEY2_CODE, sg_key_mag->ts02n_key_def_s->key2_long_press_time)) {
            sg_key_mag->ts02n_key_def_s->key2_long_press_cb();
            TUYA_APP_LOG_DEBUG("key2 is long pressed");
        }
        /* 短按 */
        if (sg_key_mag->ts02n_key_def_s->key2_short_press_cb != NULL) {
            if (is_key_release_to_release_less_time(KEY2_CODE, sg_key_mag->ts02n_key_def_s->key2_long_press_time)) {
                sg_key_mag->ts02n_key_def_s->key2_short_press_cb();
                TUYA_APP_LOG_DEBUG("key2 is pressed");
            }
        }
    } else {
        /* 短按 */
        if (sg_key_mag->ts02n_key_def_s->key2_short_press_cb != NULL) {
            if (is_key_press_over_time(KEY2_CODE, KEY_PRESS_SHORT_TIME)) {
                sg_key_mag->ts02n_key_def_s->key2_short_press_cb();
                TUYA_APP_LOG_DEBUG("key2 is pressed");
            }
        }
    }
}

/* 按键定时循环函数 */
void ts02n_key_loop(void)
{
    static uint32_t s_key_scan_tm = 0;
	/* 定时时间判断 */
	if (!clock_time_exceed(s_key_scan_tm, (sg_key_mag->ts02n_key_def_s->scan_time)*1000)) {
		return;
	}
	s_key_scan_tm = clock_time();	/* 记录当前时间 */
    update_key_status(sg_key_mag->ts02n_key_def_s->scan_time);	/* 扫描按键状态 */
    detect_and_handle_key_event();	/* 判断与处理 */
}
（5）温度采集与处理

根据硬件方案中关于NTC温度传感器的介绍可知，通过ADC模块采集到的端口电压值即可换算出当前温度值。由于本案例使用的芯片平台不支持浮点数运算，这里我们采用查表法来获取当前温度。首先我们编写一个脚本，将NTC的R-T表中的电阻值读出并转换为电压值，然后按照顺序放入数组中存储，这样我们就可以通过查询数组将电压值转换为温度值。脚本可在tuya-iotos-embeded-demo-ble-temperature-alarm中获取。

a. 温度采集

NTC端口设置如下：

温度传感器管脚
温度传感器 P_NTCADC/GPIO_PB6

代码实现：

#define P_NTC               	GPIO_PB6	/* ADC */
#define TEMP_ARRAY_MIN_VALUE    0			/* 数组中第一个数据对应的温度 */
#define TEMP_ARRAY_SIZE         120			/* 数据个数 */

/* NTC(B3950/100K) 温度-电压对应表 */
const uint16_t vol_data_of_temp[TEMP_ARRAY_SIZE] = {
     190,  199,  209,  219,  229,  240,  251,  263,  275,  288,  301,  314,  328,  342,  357,  372,  388,  404,  420,  437, /* 0 ~ 19 */
     455,  473,  491,  510,  530,  549,  570,  591,  612,  634,  656,  679,  702,  725,  749,  774,  799,  824,  849,  875, /* 20 ~ 39 */
     902,  928,  955,  982, 1010, 1038, 1066, 1094, 1123, 1152, 1181, 1210, 1239, 1268, 1298, 1327, 1357, 1386, 1416, 1446, /* 40 ~ 59 */
    1475, 1505, 1535, 1564, 1593, 1623, 1652, 1681, 1710, 1738, 1767, 1795, 1823, 1851, 1878, 1906, 1933, 1959, 1986, 2012, /* 60 ~ 79 */
    2038, 2063, 2088, 2113, 2138, 2162, 2185, 2209, 2232, 2255, 2277, 2299, 2320, 2342, 2362, 2383, 2403, 2423, 2442, 2461, /* 80 ~ 99 */
    2480, 2498, 2516, 2534, 2551, 2568, 2584, 2600, 2616, 2632, 2647, 2662, 2676, 2690, 2704, 2718, 2731, 2744, 2757, 2769  /* 100 ~ 119 */
};

/* NTC端口及ADC模块初始化 */
void ntc_adc_init(void)
{
	adc_init();
	adc_base_init(P_NTC);
	adc_power_on_sar_adc(1);
}

/* 判断电压值是否在data[num1]和data[num2]之间 */
static uint8_t is_vol_value_between(uint16_t value, uint8_t num1, uint8_t num2)
{
    if ((value >= vol_data_of_temp[num1]) && (value <= vol_data_of_temp[num2])) {
        return 1;
    } else {
        return 0;
    }
}

/* 判断电压值更接近data[num1]还是data[num2] */
static uint8_t get_closer_num(uint16_t value, uint8_t num1, uint8_t num2)
{
    if ((value - vol_data_of_temp[num1]) < (vol_data_of_temp[num2] - value)) {
        return num1;
    } else {
        return num2;
    }
}

/* 转换电压值为温度值 */
static uint8_t transform_vol_to_temp(uint16_t vol_value)
{
    uint8_t comp_num;
    uint8_t min = 0;
    uint8_t max = TEMP_ARRAY_SIZE - 1;
    uint8_t temp = 0;

    if (vol_value <= vol_data_of_temp[min]) {
        return TEMP_ARRAY_MIN_VALUE;
    }
    if (vol_value >= vol_data_of_temp[max]) {
        return (TEMP_ARRAY_MIN_VALUE + TEMP_ARRAY_SIZE - 1);
    }
    while (1) {
        comp_num = (max + min) / 2;
        if (vol_value == vol_data_of_temp[comp_num]) {
            temp = comp_num + TEMP_ARRAY_MIN_VALUE;
            break;
        } else if (vol_value < vol_data_of_temp[comp_num]) {
            if (is_vol_value_between(vol_value, comp_num-1, comp_num)) {
                temp = get_closer_num(vol_value, comp_num-1, comp_num) + TEMP_ARRAY_MIN_VALUE;
                break;
            } else {
                max = comp_num;
            }
        } else {
            if (is_vol_value_between(vol_value, comp_num, comp_num+1)) {
                temp = get_closer_num(vol_value, comp_num, comp_num+1) + TEMP_ARRAY_MIN_VALUE;
                break;
            } else {
                min = comp_num;
            }
        }
    }
    return temp;
}

/* 获取当前温度 */
uint8_t get_cur_temp(void)
{
    uint8_t ntc_temp;
    uint16_t ntc_vol_value;
    /* NTC端口及ADC模块初始化(需要在每次读取前初始化) */
    ntc_adc_init();
    /* 读取A/D转换结果(这里得到的直接是单位为mV的电压值) */
    ntc_vol_value = (uint16_t)adc_sample_and_get_result();
    TUYA_APP_LOG_DEBUG("voltage: %d", ntc_vol_value);
    /* 将电压值转换为温度值 */
    ntc_temp = transform_vol_to_temp(ntc_vol_value);
    TUYA_APP_LOG_DEBUG("temperature: %d", ntc_temp);
    return ntc_temp;
}
（6）应用层功能实现

在以上相关驱动代码实现后，下面进行智能烧水壶相关功能的实现。

a. 初始化函数与主循环函数的编写

/* 初始化函数 【在tuya_ble_app_demo.c的tuya_ble_app_init()函数中调用】 */
void tuya_app_kettle_init(void)
{
    memset(&g_kettle, 0, sizeof(g_kettle));				/* 变量初始化 */
    memset(&g_kettle_flag, 0, sizeof(g_kettle_flag));	/* 标志初始化 */
    set_keep_warm_temp(TEMP_KEEP_WARM_DEFAULT);			/* 设置默认保温温度 */

    led_init();											/* 指示灯端口初始化 */
    relay_init();										/* 继电器端口初始化 */
    buzzer_pwm_init();									/* 蜂鸣器端口及PWM模块初始化 */
    ntc_adc_init();										/* 温度传感器端口及ADC模块初始化 */
    ts02n_key_init(&user_ts02n_key_def_s);				/* 按键注册并初始化 */
    ble_connect_status_init();							/* 蓝牙连接状态初始化(在下一节介绍) */
}

/* 主循环函数 【在tuya_ble_app_demo.c的app_exe()函数中调用】 */
void tuya_app_kettle_loop(void)
{
	update_ble_status();								/* 蓝牙连接状态更新(在下一节介绍) */
    update_cur_temp();									/* 温度更新处理 */
    ts02n_key_loop();									/* 按键循环处理 */
    update_kettle_mode();								/* 模式更新处理 */
    update_led_green_status();							/* 指示灯定时处理 */
    update_buzzer_status();								/* 蜂鸣器定时处理 */
}

b. 温度更新与故障检测

每2秒更新一次温度值，如果发生温度变化，则将数据更新上报至云端，并进行一次故障检测；如果故障状态变化，更新故障信息至云端：

#define TEMP_UPPER_LIMIT        105			/* 报警温度阈值 */
#define TIME_GET_TEMP           2000        /* 温度更新间隔:2s */

typedef BYTE_T FAULT_E; 					/* 故障 */
#define FAULT_NORMAL            0x00		/* 正常 */
#define FAULT_LACK_WATER        0x01		/* 缺水 */

/* 更新故障信息 */
static void update_fault(FAULT_E fault)
{
    g_kettle.fault = fault;
    report_one_dp_data(DP_ID_FAULT, g_kettle.fault);
    TUYA_APP_LOG_DEBUG("fault: %d", g_kettle.fault);
}

/* 烧水壶停止工作 */
static void stop_kettle(void)
{
    set_boil_turn(OFF);
    set_keep_warm_turn(OFF);
    set_led_red(OFF);
    set_led_orange(OFF);
    set_led_green_status(OFF);
    set_relay(OFF);
}

/* 故障检测处理 */
static void detect_and_handle_fault_event(void)
{
    if (g_kettle.fault == FAULT_NORMAL) {
        if (g_kettle.temp_cur >= TEMP_UPPER_LIMIT) {	/* 超过温度上限时 */
            update_fault(FAULT_LACK_WATER);				/* 更新故障状态为缺水干烧 */
            set_buzzer_mode(BUZZER_MODE_FAULT);			/* 蜂鸣器长鸣 */
            stop_kettle();								/* 停止工作 */
        }
    } else {
        if (g_kettle.temp_cur < TEMP_UPPER_LIMIT) {		/* 温度恢复后 */
            update_fault(FAULT_NORMAL);					/* 更新故障状态为无故障 */
            set_buzzer_mode(BUZZER_MODE_STOP);			/* 蜂鸣器停止 */
            set_work_mode(MODE_NATURE);					/* 切换至自然模式 */
        }
    }
}

/* 更新当前温度 */
static void update_cur_temp(void)
{
    uint8_t temp;
    static uint32_t s_get_temp_tm = 0;
	/* 2秒定时 */
    if (!clock_time_exceed(s_get_temp_tm, TIME_GET_TEMP*1000)) {
        return;
    }
    s_get_temp_tm = clock_time();
	/* 获取当前温度 */
    temp = get_cur_temp();
    if (g_kettle.temp_cur != temp) {		/* 温度变化？ */
        g_kettle.temp_cur = temp;			/* 更新当前温度 */
        report_one_dp_data(DP_ID_TEMP_CUR, g_kettle.temp_cur);
        detect_and_handle_fault_event();	/* 故障检测处理 */
    }
}

c. 按键注册与事件响应处理

按键管脚及相关操作的主要响应内容设置如下：

按键管脚操作响应
煮沸键 P_KEY_BOILP7/GPIO_PC3轻触打开/关闭煮沸功能
保温键 P_KEY_KEEPP8/GPIO_PC2轻触
长按5秒		打开/关闭保温功能
进入配网状态

按键信息注册如下：

#define P_KEY_BOIL	GPIO_PC3
#define P_KEY_KEEP	GPIO_PC2

/* 用户按键信息注册 */
TS02N_KEY_DEF_T user_ts02n_key_def_s = {
    .key1_pin = P_KEY_BOIL,         					/* P7 */
    .key2_pin = P_KEY_KEEP,         					/* P8 */
    .key1_short_press_cb = key_boil_short_press_cb_fun,	/* 煮沸键轻触处理 */
    .key2_short_press_cb = key_keep_short_press_cb_fun,	/* 保温键轻触处理 */
    .key1_long_press_cb = NULL,							/* 无煮沸键长按功能 */
    .key2_long_press_cb = key_keep_long_press_cb_fun,	/* 保温键长按5秒处理 */
    .key1_long_press_time = 0,      					/* 无煮沸键长按功能 */
    .key2_long_press_time = 5000,   					/* 5s */
    .scan_time = 10,                					/* 10ms */
};

/* 切换煮沸开/关状态 */
static void switch_boil_turn(void)
{
    if (g_kettle.boil_turn == ON) {
        set_boil_turn(OFF);		/* 关闭煮沸功能(具体执行内容在[云端控制(3)]中介绍) */
    } else {
        set_boil_turn(ON);		/* 打开煮沸功能 */
    }
}

/* 切换保温开/关状态 */
static void switch_keep_warm_turn(void)
{
    if (g_kettle.keep_warm_turn == ON) {
        set_keep_warm_turn(OFF);/* 关闭保温功能(具体执行内容在[云端控制(3)]中介绍) */
    } else {
        set_keep_warm_turn(ON);	/* 打开保温功能 */
    }
}

/* 煮沸键轻触处理 */
void key_boil_short_press_cb_fun(void)
{
    if (g_kettle.fault != FAULT_NORMAL) {	/* 故障发生时按键无效 */
        return;
    }
    switch_boil_turn();						/* 切换煮沸开/关状态 */
    set_buzzer_mode(BUZZER_MODE_ONCE);		/* 设置蜂鸣器模式为“滴一声” */
}

/* 保温键轻触处理 */
void key_keep_short_press_cb_fun(void)
{
    if (g_kettle.fault != FAULT_NORMAL) {	/* 故障发生时按键无效 */
        return;
    }
    switch_keep_warm_turn();				/* 切换保温开/关状态 */
    set_buzzer_mode(BUZZER_MODE_ONCE);		/* 设置蜂鸣器模式为“滴一声” */
}

/* 保温键长按5秒处理 */
void key_keep_long_press_cb_fun(void)
{
    if (F_BLE_BONDING == SET) {				/* 已被用户绑定时无效 */
        return;
    }
    try_to_connect_ble();					/* 尝试配网(具体执行内容在[云端控制(1)]中介绍) */
    set_buzzer_mode(BUZZER_MODE_ONCE);		/* 设置蜂鸣器模式为“滴一声” */
}

d. 模式更新与处理

根据功能设定，我们将烧水壶的工作模式拆分为以下4个模式：

模式条件状态
自然模式煮沸、保温功能均关闭指示灯、加热均关闭
煮沸模式煮沸功能打开红灯亮、橙灯灭、绿灯灭、加热打开
保温模式1煮沸功能关闭，保温功能打开，自来水模式红灯灭、橙灯亮、绿灯灭、加热打开
保温模式2煮沸功能关闭，保温功能打开，纯净水模式红灯灭、橙灯/绿灯/加热根据当前温度设定状态

代码实现：

/* 工作模式 */
typedef BYTE_T MODE_E; 
#define MODE_NATURE             0x00
#define MODE_BOIL               0x01
#define MODE_KEEP_WARM1         0x02
#define MODE_KEEP_WARM2         0x03
/* 用水类型 */
typedef BYTE_T WATER_TYPE_E; 
#define WATER_TYPE_TAP          0x00
#define WATER_TYPE_PURE         0x01
/* 温度相关 */
#define TEMP_BOILED             97	/* 煮沸温度 */
#define TEMP_KEEP_WARM_DEFAULT  55	/* 默认保温温度 */

/* 自然模式 */
static void kettle_mode_nature(void)
{
    set_led_red(OFF);
    set_led_orange(OFF);
    set_led_green_status(OFF);
    set_relay(OFF);
}

/* 煮沸模式 */
static void kettle_mode_boil(void)
{
    if (g_kettle.temp_cur >= TEMP_BOILED) {	/* 达到煮沸温度时 */
        set_water_type(WATER_TYPE_PURE);	/* 更新用水类型为纯净水 */
        set_boil_turn(OFF);					/* 关闭煮沸功能 */
        set_relay(OFF);						/* 关闭加热 */
    } else {
        set_relay(ON);						/* 打开加热 */
    }
}

/* 保温模式1 */
static void kettle_mode_keep_warm1(void)
{
    if (g_kettle.temp_cur >= TEMP_BOILED) {	/* 达到煮沸温度时 */
        set_water_type(WATER_TYPE_PURE);	/* 更新用水类型为纯净水 */
        set_relay(OFF);						/* 关闭加热 */
    } else {
        set_relay(ON);						/* 打开加热 */
    }
}

/* 保温模式2 */
static void kettle_mode_keep_warm2(void)
{
	/* 未达到保温温度时，橙灯亮，绿灯灭，温度高时加热关闭，温度低时加热打开 */
    if (g_kettle.temp_cur > g_kettle.temp_set) {
        set_led_orange(ON);
        set_led_green_status(OFF);
        set_relay(OFF);
    } else if (g_kettle.temp_cur < (g_kettle.temp_set - 3)) {
        set_led_orange(ON);
        set_led_green_status(OFF);
        set_relay(ON);
    /* 达到保温温度时，橙灯灭，绿灯亮，加热关闭 */
    } else {
        set_led_orange(OFF);
        set_led_green_status(ON);
        set_relay(OFF);
    }
}

/* 运行各模式 */
static void run_kettle(void)
{
    if (g_kettle.fault != FAULT_NORMAL) {
        return;
    }
    switch (g_kettle.mode) {
    case MODE_NATURE:
        kettle_mode_nature();
        break;
    case MODE_BOIL:
        kettle_mode_boil();
        break;
    case MODE_KEEP_WARM1:
        kettle_mode_keep_warm1();
        break;
    case MODE_KEEP_WARM2:
        kettle_mode_keep_warm2();
        break;
    default:
        break;
    }
}

/* 模式更新 */
static void update_kettle_mode(void)
{
    if (g_kettle.boil_turn == ON) {					/* 煮沸功能打开时 */
        set_work_mode(MODE_BOIL);					/* 进入煮沸模式 */
    } else if (g_kettle.keep_warm_turn == ON){		/* 煮沸功能关闭、保温功能打开时 */
        if (g_kettle.water_type == WATER_TYPE_TAP) {/* 使用自来水时 */
            set_work_mode(MODE_KEEP_WARM1);			/* 进入保温模式1(先煮沸再保温) */
        } else {									/* 使用纯净水时 */
            set_work_mode(MODE_KEEP_WARM2);			/* 进入保温模式2(直接保温) */
        }
    } else {										/* 煮沸、保温功能都关闭开时 */
        set_work_mode(MODE_NATURE);					/* 进入自然模式 */
    }
    run_kettle();
}

以上就是蓝牙版智能烧水壶离线控制功能实现操作方法，如果大家有疑问或者有更好的方案欢迎留言讨论~

三明治开发社区
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
智能烧水壶(Bluetooth LE版)——硬件设计篇
三明治开发社区的博客
07-17 3166
一、概述 前面已经设计了一款WIFI控制的智能烧水壶，为了满足不同使用群体的需求，又设计了一款蓝牙控制的智能烧水壶，硬件电路上兼容，只需要把WIFI模块换成BLE模块即可。 1、功能 （1）APP控制，触摸按键控制。 （2）恒温控制，保温模式可选，预约定时控制，煮水模式可选。 （3）干烧断电，故障告警。 2、硬件框图 二、硬件方案介绍 于涂鸦智能的一款低功耗嵌入式BLE协议的BLE模组开发的一款主控板。 我们选取此模组作为主控来实现智能化的水壶。电路分为主控...
一个蓝牙芯片功能函数的设计考虑
quanquanxiaobu的博客
11-15 454
先从要实现什么功能说起吧，要实现十五分钟未收到蓝牙报文则关机（为了省电） 我不知道会用多长时间读完这篇，我知道的是将一些设计时的考虑想法落实到文字上是多么费时多么费精力的一件事，那个函数从考虑到验证四十多分钟，但落实到文字上要五六个小时 蓝字我觉得是最概括性的，红字是我认为最重要的，绿字是我写完这篇之后自己不能解答的，希望阅读者能在评论区留下宝贵意见， 同时关于程序上有什么不当的地方，也希望阅读者能在评论区留下宝贵意见--------渴望能得到提升的拳拳小布
基于物联网控制的智能热水壶实现自动化烧水研究.rar
09-19
基于物联网控制的智能热水壶实现自动化烧水研究.rar
基于物联网控制的智能热水壶实现自动化烧水研究.pdf
09-16
基于物联网控制的智能热水壶实现自动化烧水研究.pdf
【电子通识】电热水壶组成结构及主要器件原理
最新发布
一点硬件
04-14 804
电热水壶（又名电水壶、电烧水壶）是目前市场上极为普及的小型家用电器之一。电热水壶是一种具有蒸汽智能感应控制、过热保护、水沸或水干自动断电功能的器具，可将水快速煮沸，使用便捷。
软件定时器实现
hjj801006的专栏
05-31 247
一个软件定时器的实现
泰凌微8258长按小灯开启\关闭（包含定时器）
weixin_55714606的博客
09-22 254
定时器用来判断长按三秒时间的到达，定义一个开始时间start_tick用来接收按键按下的开始时间clock_time()，通过clock_time_exceed()函数来判断时间是否到达。标志位默认为1小灯灭led_status=1，为了后续判断更加准确，因为题目里明确说明点亮闪烁后再次长按熄灭，所以第二次长按的判断应该嵌套在第一次点亮判断的里面。长按按键3秒时所有灯闪烁，再次长按按键3秒所有灯停止闪烁，返回到闪烁之前的状态。（我只做了一个灯其他灯灯同理）如有不对的地方欢迎指正~
基于51单片机的烧水壶定时器含仿真
01-12
本项目"基于51单片机的烧水壶定时器含仿真"就是这样一个实例，它利用51单片机的控制能力，实现对烧水壶的定时功能，以提高烧水过程的安全性和便利性。 一、51单片机基础 51单片机是Intel公司8051系列的一种，其...
Arduino打造的智能水壶，保证每日饮水量-电路方案
04-20
一个改造过的水瓶，可以跟踪...为了跟踪我的水摄入量，我使用Arduino使我的水瓶变得智能。 它可以: 1.跟踪我的每日饮水量 2.跟踪我的每周平均水摄入量 3.提醒我要喝水 4.跟踪上次喝水时间 5.一次充电可运行一个月以上。
网络游戏-一种基于无线网络控制的自动烧水壶.zip
09-20
标题中的“网络游戏-一种基于无线网络控制的自动烧水壶”揭示了本次讨论的主题，它是一种结合了网络技术和物联网技术的智能家电产品。这个自动烧水壶可以通过无线网络进行远程控制，让用户体验到智能家居的便利性。...
telink sig mesh存储流程-light
lixingdian的博客
02-10 367
在主循环中有个的system_time_run中的light_par_save_proc中，检测全局变量tick_light_save。 void light_par_save_proc() { // save proc if(tick_light_save && clock_time_exceed(tick_light_save, 3*1000*1000)){ tick_light_save = 0; if(!is_actived_factory_test_mode()){
【懒人必备】智能窗帘机器人，告别手动拉窗帘——软件功能实现篇
三明治开发社区的博客
07-27 1975
简介：智能窗帘机器人方案，无需专业人员上门安装，使普通窗帘秒变智能窗帘 普通控制 有打开、关闭和停止三个按钮。 停止按钮在任何情况下都能保证使电机停转。 百分比控制 按照窗帘长度的百分比来控制。 自动测量窗帘长度 自动测量窗帘机器人跑全程所需时间。 电机正反转 改变电机运行时默认的正反转方向。 改变电机打开窗帘为正转或反转 动作检测 检测到手动开，将窗帘全部打开。检测到手动关，将窗帘全部关闭。 APP上名称为：自启动开关
使用git对AD实现版本控制(离线模式)
weixin_46691876的博客
12-12 1649
这是一篇关于如何用git对AD21的PCB文档进行版本控制的技术文章。
ST17H26定时器注意事项
qinrenzhi的博客
10-14 654
ST17H26 SDK中没有传统意义上的定时器接口，所有涉及定时器的功能以如下查询处理方式为基础进行： u32 a_trig_tick; int a_trig_flg = 0; while(1) { if(A) { a_trig_tick = clock_time(); a_trig_flg = 1; } if(a_trig_flg &&clock_time_exceed(a_
避免 Time Limit Exceeded
热门推荐
MTOY_320的博客
10-27 1万+
经常会遇到这种令人抓狂的情况 自己编写的程序在codeblocks上怎么编译运行都能输出正确结果 然而一提交，却无法Accept,很多时候显示的并不是Wrong Answer 而是比Wrong Answer更令人绝望的  。 在oj中，给定的Time Limit 是1000MS,出现Time Limit  Exceeded则说明这个程序的运行时间超过了这个限度。 经过几道题，我猜想了几个
USB HID常识
weixin_34194317的博客
06-29 238
Using USB terminology, a device may send or receive a transaction every USB frame (1 millisecond). A transaction may be made up of multiple packets (token, data, handshake) but is limited in size...
CA51F3芯片有开和关的引脚，两个触摸按键分别控制开关的烧水壶代码
06-10
好的，以下是使用CA51F3芯片，实现两个触摸按键分别控制开关的烧水壶的基本代码框架： ```c #include <REG_CA51F3.H> // 定义两个触摸按键的引脚 sbit key1 = P1^0; sbit key2 = P1^1; // 定义烧水壶的开关引脚 sbit kettle = P2^0; void main() { // 初始化GPIO引脚 key1 = 1; key2 = 1; kettle = 0; // 无限循环中读取按键状态并控制烧水壶开关 while (1) { if (key1 == 0) // 如果按键1被按下 { kettle = ~kettle; // 切换烧水壶的开关状态 while (!key1); // 等待按键1松开 } if (key2 == 0) // 如果按键2被按下 { kettle = ~kettle; // 切换烧水壶的开关状态 while (!key2); // 等待按键2松开 } } } ``` 上述代码中，我们首先定义了两个触摸按键的引脚和烧水壶的开关引脚，并在程序开始时将它们初始化。然后进入一个无限循环中，不断读取按键状态并控制烧水壶开关。 当按键1被按下时，我们直接切换烧水壶的开关状态，并等待按键1松开；当按键2被按下时，同样切换烧水壶的开关状态，并等待按键2松开。 请注意，这只是一个基础的代码框架，还需要根据具体硬件和需求进行修改和完善。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值