pets-device/BLE-USB_Dongle
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

已裁剪掉逗猫棒的业务程序，原有的蓝牙转USB功能不受影响

Browse Source
This commit is contained in:
wuchuyuan
2026-07-24 12:26:52 +08:00
parent b3f06697a6
commit c843fb24e0
61 changed files with 2195 additions and 7393 deletions
Download Patch File Download Diff File Expand all files Collapse all files
apps/earphone/app_main.c
+26 -328
View File
@@ -45,9 +45,6 @@ u8 user_at_cmd_send_support = 1;
#endif
extern void usr_le_notify_data();
/*任务列表 */
const struct task_info task_info_table[] = {
{"app_core", 1, 0, 768+768, 256 },
@@ -149,39 +146,15 @@ const struct task_info task_info_table[] = {
APP_VAR app_var;
USR_VAR usr_var;
void clr_wdt(void);
u8 usr_get_ldoin();
void app_earphone_play_voice_file(const char *name);
extern void usr_clear_battery_cache();
extern int cpu_reset_by_soft();
extern int audio_dec_init();
extern int audio_enc_init();
extern u32 timer_get_ms(void);
extern void uart_dev_test_main();
extern int utc_test_main();
extern void timer_pwm_test(void);
extern int ana_demo();
extern void uart_dev_main_init();
extern void usr_check_mcu_all_sta();
extern int utc_dec_test_main();
extern int plan_test_main();
extern void usr_clear_moto();
extern void usr_rtc_get_time();
extern void usr_read_device_sta();
extern void usr_rcsp_process_timer();
extern void usr_clear_pair_info_noreset();
extern void usr_disable_intterupt();
extern void usr_disable_charge_intterupt();
extern void app_rtc_task();
extern void usr_plan_init();
u8 power_reset_flag=0;///不定义的话RTC编译报错
/*
* 2ms timer中断回调函数
*/
void timer_2ms_handler()
{
}
u8 power_reset_flag = 0;
void app_var_init(void)
{
@@ -190,52 +163,6 @@ void app_var_init(void)
}
void check_power_on_key(void)
{
u32 delay_10ms_cnt = 0;
usr_var.usr_power_charge_flag=2;
os_time_dly(10);
while (1) {
clr_wdt();
os_time_dly(1);
extern u8 get_power_on_status(void);
if (get_power_on_status()) {
log_info("+");
delay_10ms_cnt++;
if (delay_10ms_cnt > 60) {
/* extern void set_key_poweron_flag(u8 flag); */
/* set_key_poweron_flag(1); */
_usr_module_cfg.local_moto_mode=1;
usr_var.usr_power_charge_flag=2;
app_var.play_poweron_tone=1;
//wdt_init(WDT_256MS);
//while(1);
return;
}
}
else if((usr_get_ldoin())||(gpio_read(IO_PORTC_05)==0))
{
putchar('*');
delay_10ms_cnt++;
if (delay_10ms_cnt > 10) {
usr_var.usr_power_charge_flag=1;
//wdt_init(WDT_256MS);
//while(1);
return;
}
}
else {
log_info("-");
delay_10ms_cnt = 0;
log_info("enter softpoweroff\n");
usr_clear_battery_cache();
power_set_soft_poweroff();
}
}
}
__attribute__((weak))
u8 get_charge_online_flag(void)
{
@@ -257,312 +184,83 @@ static void app_poweron_check(int update)
return;
}
#endif
//#ifdef CONFIG_RELEASE_ENABLE
#if TCFG_POWER_ON_NEED_KEY
check_power_on_key();
#endif
//#endif
#endif
}
void usr_led_w_out(u8 flag)
{
gpio_set_direction(IO_PORTA_07, !flag);
gpio_set_pull_up(IO_PORTA_07, 0);
gpio_set_pull_down(IO_PORTA_07,0);
gpio_set_output_value(IO_PORTA_07,!flag);
}
void usr_led_b_out(u8 flag)
{
gpio_set_direction(IO_PORTA_08,!flag);
gpio_set_pull_down(IO_PORTA_08,0);
gpio_set_pull_up (IO_PORTA_08,0);
gpio_set_output_value(IO_PORTA_08,!flag);
}
extern void usr_moto_timer_init();
u8 usr_get_ldoin()
{
if(gpio_read(IO_PORTG_08)==0)return 1;
return 0;
}
u8 usr_get_full()
{
if(gpio_read(IO_PORTC_05)==0)return 1;
return 0;
}
u8 usr_get_ldoin_all()
{
if(usr_get_ldoin()||usr_get_full())return 1;
return 0;
}
void usr_charge_deal()
{
static u8 rled_flag=0;
u8 usr_chg_in=0;
usr_chg_in=usr_get_ldoin();
//printf("usr_chg_in = %d\n",usr_chg_in);
if(usr_chg_in)
{
// charge_check_and_set_pinr(0);
usr_clear_moto();
if(usr_get_full())
{
rled_flag=1;
if(usr_var.usr_power_charge_flag==2)
{
usr_var.usr_power_charge_flag=1;
usr_le_notify_data();
}
printf("charge full power off00\n");
//power_set_soft_poweroff();
}
else
{
rled_flag=!rled_flag;
printf("charging \n");
if(usr_var.usr_power_charge_flag==2)
{
usr_var.usr_power_charge_flag=1;
usr_le_notify_data();
}
}
usr_led_b_out(0);
usr_led_w_out(rled_flag);
}
else
{
// charge_check_and_set_pinr(1);
if(usr_get_full())
{
if(usr_var.usr_power_charge_flag==2)
{
usr_var.usr_power_charge_flag=1;
usr_le_notify_data();
}
usr_clear_moto();
usr_led_b_out(0);
rled_flag=1;
usr_led_w_out(rled_flag);
printf("charge full power off11\n");
}
else
{
if(usr_var.usr_power_charge_flag==1)
{
usr_var.usr_power_charge_flag=2;
usr_var.usr_allow_to_sleep_cnt=8;
//power_set_soft_poweroff();
printf("charge plug power off\n");
}
}
}
usr_rtc_get_time();
//read_sys_time(&usr_current_time1);
//printf("#### usr_current_time1 %d-%d-%d %d:%d:%d \n",usr_current_time1.year,usr_current_time1.month,usr_current_time1.day,usr_current_time1.hour,usr_current_time1.min,usr_current_time1.sec);
usr_rcsp_process_timer();
}
#if 0
const struct sys_time def_sys_time = { //初始一下当前时间
.year = 2020,
.month = 1,
.day = 1,
.hour = 0,
.min = 0,
.sec = 0,
};
const struct rtc_dev_platform_data rtc_init_data=
{
.default_sys_time = &def_sys_time,
.default_alarm = NULL,
.clk_sel = CLK_SEL_32K,//CLK_SEL_LRC,//CLK_SEL_32K,
.cbfun = NULL, //闹钟中断的回调函数,用户自行定义
/* .cbfun = alarm_isr_user_cbfun, */
};
#endif // 0
extern void bt_osc_offset_ext_updata(s32 offset);
extern void usr_test_protocol(void);
void app_main()
{
int update = 0;
u32 addr = 0, size = 0;
struct intent it;
u16 pair_cnt=0;
log_info("app_main........4444444444444.......#####\n");
log_info("app_main usb-ble bridge\n");
bt_osc_offset_ext_updata(11);
//usr_disable_charge_intterupt();
app_rtc_task();
//alarm_init();
usr_var.usr_ota_succ_flag=0;
//rtc_init(&rtc_init_data);
//read_sys_time(&usr_current_time1);
//printf("#### usr_current_time1 %d %d %d %d %d %d \n",usr_current_time1.year,usr_current_time1.month,usr_current_time1.day,usr_current_time1.hour,usr_current_time1.min,usr_current_time1.sec);
// usb_iomode(1);
usr_var.usr_ota_succ_flag = 0;
gpio_set_die(IO_PORTB_01, 1);
gpio_set_direction(IO_PORTB_01, 1);
gpio_set_pull_up(IO_PORTB_01, 1);
gpio_set_pull_down(IO_PORTB_01,0);
// gpio_set_die(IO_PORTG_08, 1);///充电插入检测
// gpio_set_direction(IO_PORTG_08, 1);
// gpio_set_pull_up(IO_PORTG_08, 1);
// gpio_set_pull_down(IO_PORTG_08,0);
// gpio_set_die (IO_PORTC_05,1);///充满检测
// gpio_set_direction(IO_PORTC_05,1);
// gpio_set_pull_down(IO_PORTC_05,0);
// gpio_set_pull_up (IO_PORTC_05,1);
//usr_disable_intterupt();
gpio_set_pull_down(IO_PORTB_01, 0);
#ifndef CONFIG_DEBUG_ENABLE
uart_dev_test_main();
#endif // CONFIG_DEBUG_ENABLE
#endif
app_var.start_time = timer_get_ms();
#if (defined(CONFIG_MEDIA_NEW_ENABLE) || (defined(CONFIG_MEDIA_DEVELOP_ENABLE)))
/*解码器*/
audio_enc_init();
audio_dec_init();
#endif
//rtc_init(&rtc_init_data);
#ifdef BT_DUT_INTERFERE
void audio_demo(void);
audio_demo();
#endif/*BT_DUT_INTERFERE*/
#endif
#ifdef BT_DUT_ADC_INTERFERE
void audio_adc_mic_dut_open(void);
audio_adc_mic_dut_open();
#endif/*BT_DUT_ADC_INTERFERE*/
#endif
if (!UPDATE_SUPPORT_DEV_IS_NULL()) {
update = 0;//update_result_deal();
update = 0;
}
app_var_init();
#if TCFG_MC_BIAS_AUTO_ADJUST
mc_trim_init(update);
#endif/*TCFG_MC_BIAS_AUTO_ADJUST*/
//if (get_charge_online_flag())
if(0){
#if(TCFG_SYS_LVD_EN == 1)
vbat_check_init();
#endif
init_intent(&it);
it.name = "idle";
it.action = ACTION_IDLE_MAIN;
start_app(&it);
} else {
_usr_module_cfg.local_moto_mode=0;
check_power_on_voltage();
check_power_on_voltage();
app_poweron_check(update);
app_poweron_check(update);
//uart_dev_main_init();
//sys_timeout_add(NULL,usr_check_mcu_all_sta,1000);
if(usr_get_ldoin()||usr_get_full())
{
usr_var.usr_power_charge_flag=1;
_usr_module_cfg.local_moto_mode=3;
}
else
{
usr_var.usr_power_charge_flag=2;
}
//utc_dec_test_main();
//utc_test_main();
//usr_check_mcu_all_sta();
//ana_demo();
usr_read_device_sta();
usr_var.usr_goto_pair = 1;
usr_clear_pair_info_noreset();
pair_cnt=0;
timer_pwm_test();
usr_moto_timer_init();
// sys_timer_add(NULL,usr_charge_deal,1000);
//plan_test_main();
usr_led_w_out(1);
usr_read_device_sta();
usr_var.usr_goto_pair=1;
// if(app_var.play_poweron_tone==0)
// {
// _usr_module_cfg.local_moto_mode=3;
// _usr_module_cfg.usr_dizhuo_mode=0;
// _usr_module_cfg.usr_douban_mode=0;
// }
// if(usr_var.usr_power_charge_flag==2)
// {
// while(1)
// {
// delay_2ms(30);
// if(gpio_read(IO_PORTB_01)==0)
// {
// pair_cnt++;
// printf("pair_cnt = %d\n",pair_cnt);
// if(pair_cnt>=30)
// {
// pair_cnt=0;
// usr_var.usr_goto_pair=1;
// _usr_module_cfg.local_moto_mode=3;
// usr_clear_pair_info_noreset();
// break;
// }
// }
// else
// {
// pair_cnt=0;
// usr_var.usr_goto_pair=0;
// break;
// }
// }
// }
usr_plan_init();
ui_manage_init();
ui_update_status(STATUS_POWERON);
ui_manage_init();
ui_update_status(STATUS_POWERON);
#if TCFG_WIRELESS_MIC_ENABLE
extern void wireless_mic_main_run(void);
wireless_mic_main_run();
extern void wireless_mic_main_run(void);
wireless_mic_main_run();
#endif
#if TCFG_ENTER_PC_MODE
init_intent(&it);
it.name = "pc";
it.action = ACTION_PC_MAIN;
start_app(&it);
#if TCFG_ENTER_PC_MODE
init_intent(&it);
it.name = "pc";
it.action = ACTION_PC_MAIN;
start_app(&it);
#else
init_intent(&it);
it.name = "earphone";
it.action = ACTION_EARPHONE_MAIN;
start_app(&it);
init_intent(&it);
it.name = "earphone";
it.action = ACTION_EARPHONE_MAIN;
start_app(&it);
#endif
}
#if TCFG_CHARGE_ENABLE
set_charge_event_flag(1);
#endif
}
int __attribute__((weak)) eSystemConfirmStopStatus(void)
apps/earphone/board/br28/board_jl701n_demo.c
+13 -164
View File
@@ -720,80 +720,8 @@ const struct low_power_param power_param = {
};
/************************** wk_param ****************************/
struct port_wakeup port0 = {
.iomap = IO_PORTB_01, //唤醒口选择
.pullup_down_enable = ENABLE, //配置I/O 内部上下拉是否使能
.edge = FALLING_EDGE, //唤醒方式选择,可选：上升沿\下降沿
.filter = PORT_FLT_4ms,
};
struct port_wakeup port2_1 = {
.iomap = IO_PORTA_03, //唤醒口选择
.pullup_down_enable = 0, //配置I/O 内部上下拉是否使能
.edge = FALLING_EDGE, //唤醒方式选择,可选：上升沿\下降沿
.filter = PORT_FLT_16ms,
};
struct port_wakeup port_1 = {
.iomap = IO_PORTG_08, //唤醒口选择
.pullup_down_enable = ENABLE, //配置I/O 内部上下拉是否使能
.edge = FALLING_EDGE, //唤醒方式选择,可选：上升沿\下降沿
.filter = PORT_FLT_4ms,
};
struct port_wakeup port_2 = {
.iomap = IO_PORTC_04, //唤醒口选择
.pullup_down_enable = ENABLE, //配置I/O 内部上下拉是否使能
.edge = FALLING_EDGE, //唤醒方式选择,可选：上升沿\下降沿
.filter = PORT_FLT_4ms,
};
#if (TCFG_TEST_BOX_ENABLE || TCFG_CHARGESTORE_ENABLE || TCFG_ANC_BOX_ENABLE || TCFG_UMIDIGI_BOX_ENABLE)
struct port_wakeup port1 = {
.pullup_down_enable = DISABLE, //配置I/O 内部上下拉是否使能
#if (TCFG_TEST_BOX_ANY_IO_UPDATE)
.edge = RISING_EDGE, //唤醒方式选择,可选：上升沿\下降沿
#else
.edge = FALLING_EDGE, //唤醒方式选择,可选：上升沿\下降沿
#endif
.filter = PORT_FLT_1ms,
.iomap = TCFG_CHARGESTORE_PORT, //唤醒口选择
};
#endif
#if TCFG_CHARGE_ENABLE
struct port_wakeup charge_port = {
.edge = RISING_EDGE, //唤醒方式选择,可选：上升沿\下降沿\双边沿
.filter = PORT_FLT_16ms,
.iomap = IO_CHGFL_DET, //唤醒口选择
};
struct port_wakeup vbat_port = {
.edge = BOTH_EDGE, //唤醒方式选择,可选：上升沿\下降沿\双边沿
.filter = PORT_FLT_4ms,
.iomap = IO_VBTCH_DET, //唤醒口选择
};
struct port_wakeup ldoin_port = {
.edge = BOTH_EDGE, //唤醒方式选择,可选：上升沿\下降沿\双边沿
.filter = PORT_FLT_4ms,
.iomap = IO_LDOIN_DET, //唤醒口选择
};
#endif
/* 桥接板：无休眠、无充电唤醒源 */
const struct wakeup_param wk_param = {
#if 1//(!(TCFG_LP_TOUCH_KEY_ENABLE && TCFG_LP_TOUCH_KEY1_EN))
.port[1] = &port0,
.port[2] = &port2_1,
.port[3] = &port_1,
.port[4] = &port_2,
#endif
#if 0//(TCFG_TEST_BOX_ENABLE || TCFG_CHARGESTORE_ENABLE || TCFG_ANC_BOX_ENABLE || TCFG_UMIDIGI_BOX_ENABLE)
.port[3] = &port1,
#endif
#if TCFG_CHARGE_ENABLE
.aport[0] = &charge_port,
.aport[1] = &vbat_port,
.aport[2] = &ldoin_port,
#endif
};
void gSensor_wkupup_disable(void)
@@ -1034,107 +962,35 @@ void board_set_soft_poweroff(void)
#define APP_IO_DEBUG_0(i,x) {JL_PORT##i->DIR &= ~BIT(x), JL_PORT##i->OUT &= ~BIT(x);}
#define APP_IO_DEBUG_1(i,x) {JL_PORT##i->DIR &= ~BIT(x), JL_PORT##i->OUT |= BIT(x);}
extern void usr_intterupt_close();
extern void usr_intterupt_reinit();
extern void usr_pwm_close();
extern void key_active_set(u8 port);
/* 休眠已关闭，回调仅保留 SDK 注册接口；不做 PWM/唤醒口业务 */
void sleep_exit_callback(u32 usec)
{
(void)usec;
sleep_exit_callback_common(NULL);
power_wakeup_index_enable(2, 0);
power_wakeup_index_enable(3, 0);
putchar('>');
}
void usr_disable_intterupt()
{
power_wakeup_index_enable(2, 0);
}
void usr_disable_charge_intterupt()
{
power_wakeup_index_enable(3, 0);
}
void usr_disable_all_intterupt()
{
usr_disable_intterupt();
usr_disable_charge_intterupt();
}
void sleep_enter_callback(u8 step)
void sleep_enter_callback(u8 step)
{
/* 此函数禁止添加打印 */
if (step == 1) {
usr_pwm_close();
usr_var.usr_interrupt_cnt=0;
putchar('<');
} else {
gpio_set_pull_up(TCFG_CHARGESTORE_PORT, 0);
gpio_set_pull_down(TCFG_CHARGESTORE_PORT, 0);
gpio_set_die(TCFG_CHARGESTORE_PORT, 1);
gpio_set_dieh(TCFG_CHARGESTORE_PORT, 1);
gpio_set_direction(TCFG_CHARGESTORE_PORT, 1);
sleep_enter_callback_common(NULL);
//if(_usr_module_cfg.power_on_flag==0)
{
if(_usr_module_cfg.zhengdong_kaiji)
{
if(usr_var.usr_disable_zjhendong==0)power_wakeup_index_enable(2, 1);
}
}
power_wakeup_index_enable(3, 1);
usr_intterupt_close();
}
return;
}
sleep_enter_callback_common(NULL);
}
static void port_wakeup_callback(u8 index, u8 gpio)
{
log_info("%s:%d,%d",__FUNCTION__,index,gpio);
if(index==2)
{
//if(_usr_module_cfg.power_on_flag==0)
{
usr_var.usr_interrupt_cnt=0;
usr_var.usr_intterupt_reinit_falg=0;
if(_usr_module_cfg.zhengdong_kaiji)
{
if(usr_var.usr_disable_zjhendong==0)usr_intterupt_reinit();
}
}
}
#if TCFG_UMIDIGI_BOX_ENABLE
if (index == 2) {
ldo_port_wakeup_to_cmessage();
}
#endif
switch (index) {
#if (TCFG_TEST_BOX_ENABLE || TCFG_CHARGESTORE_ENABLE || TCFG_ANC_BOX_ENABLE)
case 2:
extern void chargestore_ldo5v_fall_deal(void);
chargestore_ldo5v_fall_deal();
break;
#endif
}
(void)index;
(void)gpio;
}
static void aport_wakeup_callback(u8 index, u8 gpio, u8 edge)
{
/* log_info("%s:%d,%d",__FUNCTION__,index,gpio); */
#if TCFG_CHARGE_ENABLE
switch (gpio) {
case IO_CHGFL_DET://charge port
charge_wakeup_isr();
break;
case IO_VBTCH_DET://vbat port
case IO_LDOIN_DET://ldoin port
ldoin_wakeup_isr();
break;
}
#endif
(void)index;
(void)gpio;
(void)edge;
}
void board_power_init(void)
@@ -1145,19 +1001,12 @@ void board_power_init(void)
power_set_callback(TCFG_LOWPOWER_LOWPOWER_SEL, sleep_enter_callback, sleep_exit_callback, board_set_soft_poweroff);
#if TCFG_UMIDIGI_BOX_ENABLE
gpio_set_die(TCFG_CHARGESTORE_PORT, 1);
umidigi_chargestore_message_callback(app_umidigi_chargetore_message_deal);
#endif
power_keep_dacvdd_en(0);
power_wakeup_init(&wk_param);
power_wakeup_init(&wk_param);
power_awakeup_set_callback(aport_wakeup_callback);
power_wakeup_set_callback(port_wakeup_callback);
usr_disable_all_intterupt();
}
#endif /* #ifdef CONFIG_BOARD_JL701N_DEMO */
apps/earphone/board/br28/board_jl701n_demo_cfg.h
+3 -9
View File
@@ -747,19 +747,13 @@ DAC硬件上的连接方式,可选的配置：
//*********************************************************************************//
// 充电参数配置 //
//*********************************************************************************//
//是否支持芯片内置充电
//桥接板不使用内置充电 / 充电舱
#define TCFG_CHARGE_ENABLE 0
//是否支持开机充电
#define TCFG_CHARGE_POWERON_ENABLE DISABLE
//是否支持拔出充电自动开机功能
#define TCFG_CHARGE_OFF_POWERON_NE ENABLE
/*充电截止电压可选配置*/
#define TCFG_CHARGE_OFF_POWERON_NE DISABLE
#define TCFG_CHARGE_FULL_V CHARGE_FULL_V_4199
/*充电截止电流可选配置*/
#define TCFG_CHARGE_FULL_MA CHARGE_FULL_mA_10
/*恒流充电电流可选配置*/
#define TCFG_CHARGE_MA CHARGE_mA_50
/*涓流充电电流配置*/
#define TCFG_CHARGE_TRICKLE_MA CHARGE_mA_10
//*********************************************************************************//
@@ -787,7 +781,7 @@ DAC硬件上的连接方式,可选的配置：
//*********************************************************************************//
#define TCFG_LOWPOWER_POWER_SEL PWR_LDO15//PWR_LDO15 //电源模式设置，可选DCDC和LDO
#define TCFG_LOWPOWER_BTOSC_DISABLE 0 //低功耗模式下BTOSC是否保持
#define TCFG_LOWPOWER_LOWPOWER_SEL SLEEP_EN//DEEP_SLEEP_EN//SLEEP_EN//DEEP_SLEEP_EN //低功耗使能，蓝牙&&系统空闲可进入低功耗
#define TCFG_LOWPOWER_LOWPOWER_SEL 0 // 桥接板常供电，不进系统休眠//SLEEP_EN//DEEP_SLEEP_EN //低功耗使能，蓝牙&&系统空闲可进入低功耗
#define TCFG_LOWPOWER_VDDIOM_LEVEL VDDIOM_VOL_28V //vddiom等级
#define TCFG_LOWPOWER_OSC_TYPE OSC_TYPE_LRC //低功耗晶振类型，btosc/lrc
///#if (TCFG_AUDIO_ASR_DEVELOP && TCFG_CVP_DEVELOP_ENABLE)
apps/earphone/key_event_deal.c
+17 -77
View File
@@ -49,18 +49,13 @@ extern int bt_get_low_latency_mode();
extern void bt_set_low_latency_mode(int enable);
extern void usr_goto_pair_mode();
extern void usr_write_device_sta();
extern u16 usr_get_conn_service();
extern void usr_ble_adv_init();
extern void usr_le_notify_data();
extern void usr_clear_up();
void audio_aec_pitch_change_ctrl();
void audio_surround_voice_ctrl();
extern void start_streamer_test(void);
extern int jl_kws_voice_event_handle(struct key_event *key);
extern void usr_app_ota_init();
extern void usr_intterupt_close();
u8 poweroff_sametime_flag = 0;
@@ -377,109 +372,54 @@ int app_earphone_key_event_handler(struct sys_event *event)
switch (key_event) {
case KEY_MUSIC_PP:
//extern void usr_le_low_power_notify();
//usr_le_low_power_notify();
if(_usr_module_cfg.power_on_flag==0)break;
if(usr_var.usr_goto_pair)break;
if(usr_var.usr_power_charge_flag==1)break;
usr_var.usr_auto_off_cnt=0;
usr_var.usr_allow_to_sleep_cnt=8;
if(_usr_module_cfg.local_moto_mode==2)_usr_module_cfg.local_moto_mode=1;
else _usr_module_cfg.local_moto_mode=2;
usr_clear_up();
usr_write_device_sta();
printf("_usr_module_cfg.local_moto_mode = %d\n",_usr_module_cfg.local_moto_mode);
/* cat-toy moto mode switch removed */
break;
case KEY_IR_NUM_0:
// tone_play_by_path(TONE_POWER_ON, 0);
break;
case KEY_IR_NUM_1:
// tone_play_by_path(TONE_RING, 0);
break;
case KEY_IR_NUM_2:
// tone_play_by_path(TONE_RING, 0);
if(_usr_module_cfg.power_on_flag==0)break;
if(usr_var.usr_goto_pair)break;
if(usr_var.usr_power_charge_flag==1)break;
usr_var.usr_allow_to_sleep_cnt=8;
if (usr_var.usr_goto_pair) {
break;
}
usr_app_ota_init();
break;
case KEY_POWEROFF:
if(usr_var.usr_power_charge_flag==1)break;
goto_poweroff_cnt = 0;
poweroff_sametime_flag = 0;
goto_poweroff_flag = 1;
usr_var.usr_allow_to_sleep_cnt=8;
user_send_cmd_prepare(USER_CTRL_ALL_SNIFF_EXIT, 0, NULL);
break;
case KEY_POWEROFF_HOLD:
if(usr_var.usr_power_charge_flag==1)break;
#if (TCFG_USER_TWS_ENABLE && CONFIG_TWS_POWEROFF_SAME_TIME == 0)
if ((u32)event->arg == KEY_EVENT_FROM_TWS) {
break;
}
#endif
log_info("power flag cnt:%d cnt:%d\n", goto_poweroff_flag, goto_poweroff_cnt);
usr_var.usr_allow_to_sleep_cnt=12;
if (goto_poweroff_flag) {
if(goto_poweroff_cnt<(POWER_OFF_CNT*3))goto_poweroff_cnt++;
if (goto_poweroff_cnt < (POWER_OFF_CNT * 3)) {
goto_poweroff_cnt++;
}
if (goto_poweroff_cnt == POWER_OFF_CNT) {
//goto_poweroff_cnt = 0;
//sys_enter_soft_poweroff(NULL);
if(_usr_module_cfg.power_on_flag==0)
{
_usr_module_cfg.power_on_flag=1;
usr_var.usr_can_pair=1;
}
else
{
usr_var.usr_intterupt_reinit_falg=1;
usr_intterupt_close();
if((usr_auth_data.paired_flag==0)&&(_usr_module_cfg.zhengdong_kaiji==0))
{
sys_enter_soft_poweroff(NULL);
}
else
{
_usr_module_cfg.power_on_flag=0;
_usr_module_cfg.local_moto_mode=0;
usr_clear_up();
usr_le_notify_data();
}
if (_usr_module_cfg.power_on_flag == 0) {
_usr_module_cfg.power_on_flag = 1;
usr_var.usr_can_pair = 1;
} else {
usr_var.usr_can_pair = 1;
}
}
if(usr_var.usr_can_pair)
{
if(goto_poweroff_cnt==(POWER_OFF_CNT*3))
{
usr_var.usr_can_pair=0;
//goto_poweroff_cnt=0;
if (usr_var.usr_can_pair) {
if (goto_poweroff_cnt == (POWER_OFF_CNT * 3)) {
usr_var.usr_can_pair = 0;
usr_goto_pair_mode();
}
}
}
break;
case KEY_POWEROFF_HOLD_UP:
if((usr_var.usr_can_pair)&&(goto_poweroff_cnt<(POWER_OFF_CNT*3)))
{
usr_clear_up();
_usr_module_cfg.local_moto_mode=2;
if(usr_get_conn_service()==0)
{
usr_ble_adv_init();
}
else
{
usr_le_notify_data();
}
}
usr_var.usr_can_pair=0;
goto_poweroff_cnt=0;
usr_var.usr_allow_to_sleep_cnt=12;
usr_var.usr_can_pair = 0;
goto_poweroff_cnt = 0;
break;
case KEY_MUSIC_PREV:
//user_send_cmd_prepare(USER_CTRL_AVCTP_OPID_PREV, 0, NULL);
apps/usr_le_code/Untitled
-1
View File
@@ -1 +0,0 @@
usr_goto_pair_mode
apps/usr_le_code/usr_le_adv.c
+95 -155
View File
@@ -1,248 +1,188 @@
/******************************************************************************
* @file usr_le_adv.c
* @brief BLE broadcast / pair / reconnect (USB-BLE bridge, cat-toy logic removed)
* @author cyWu <1917507415@qq.com>
* @date 2026-07-24
* @version V1.0.0
* @history
* - V1.0.0, 2026-07-24, cyWu, trim cat-toy deps, keep bind/reconn adv
******************************************************************************/
#include "system/includes.h"
#include "app_config.h"
#include "asm/pwm_led.h"
#include "tone_player.h"
#include "ui_manage.h"
#include "app_main.h"
#include "app_task.h"
#include "asm/charge.h"
#include "app_power_manage.h"
#include "app_charge.h"
#include "user_cfg.h"
#include "audio.h"
#include "vm.h"
#include "bleproto.h"
#include "bleproto_api.h"
#include "bleproto.h"
#define LOG_TAG_CONST APP
#define LOG_TAG "[APP]"
#define LOG_ERROR_ENABLE
#define LOG_DEBUG_ENABLE
#define LOG_INFO_ENABLE
/* #define LOG_DUMP_ENABLE */
#define LOG_CLI_ENABLE
#include "debug.h"
extern u8 muti_adv_data[31];//={0};
extern u8 muti_adv_data[31];
extern u8 muti_adv_data_len;
extern u8 usr_get_full();
extern u16 usr_get_conn_service();
extern int muti_make_set_adv_data(u8* data,u8 data_len);
extern void usr_clear_plan();
extern int muti_make_set_adv_data(u8 *data, u8 data_len);
extern void usr_reset_device_sta();
extern u8 usr_get_ldoin_all();
extern void usr_set_adv_interval(u16 val);
extern u16 usr_get_adv_interval();
extern void ble_multi_trans_disconnect(void);
extern void ble_trans_module_enable(u8 flag);
extern u8 usr_get_ota_status();
extern void usr_ota_exit();
extern int muti_make_set_adv_data_updata();
void usr_ble_adv_updata();
void usr_ble_adv_init();
static int le_timer_handle=0;
static int le_timer_handle2=0;
extern void usr_led_w_out(u8 flag);
extern void usr_led_b_out(u8 flag);
extern u8 get_ldo5v_online_hw(void);
extern u8 usr_get_work_status();
extern void usr_printf_sta();
extern int muti_make_set_adv_data_updata();
static int le_timer_handle = 0;
void usr_get_pair_info()
{
int ret = 0xffff;
ret = syscfg_read(CFG_USER_PAIR_INFO, (u8 *)&usr_auth_data, sizeof(usr_auth_data));
if(ret<=0)
{
memset(&usr_auth_data,0x00,sizeof(usr_auth_data));
usr_auth_data.paired_flag=0;
int ret = syscfg_read(CFG_USER_PAIR_INFO, (u8 *)&usr_auth_data, sizeof(usr_auth_data));
if (ret <= 0) {
memset(&usr_auth_data, 0x00, sizeof(usr_auth_data));
usr_auth_data.paired_flag = 0;
syscfg_write(CFG_USER_PAIR_INFO, (u8 *)&usr_auth_data, sizeof(usr_auth_data));
}
}
void usr_write_pair_info()
{
usr_auth_data.paired_flag=1;
usr_auth_data.paired_flag = 1;
syscfg_write(CFG_USER_PAIR_INFO, (u8 *)&usr_auth_data, sizeof(usr_auth_data));
}
void usr_clear_pair_info()
{
printf("usr_clear_pair_info\n");
memset(&usr_auth_data,0x00,sizeof(usr_auth_data));
usr_auth_data.paired_flag=0;
memset(&usr_auth_data, 0x00, sizeof(usr_auth_data));
usr_auth_data.paired_flag = 0;
syscfg_write(CFG_USER_PAIR_INFO, (u8 *)&usr_auth_data, sizeof(usr_auth_data));
usr_clear_plan();
if(_usr_module_cfg.power_on_flag)sys_timeout_add(NULL,cpu_reset,600);
else sys_enter_soft_poweroff(NULL);
if (_usr_module_cfg.power_on_flag) {
sys_timeout_add(NULL, cpu_reset, 600);
} else {
sys_enter_soft_poweroff(NULL);
}
}
void usr_clear_pair_info_noreset()
{
printf("usr_clear_pair_info2\n");
memset(&usr_auth_data,0x00,sizeof(usr_auth_data));
usr_auth_data.paired_flag=0;
memset(&usr_auth_data, 0x00, sizeof(usr_auth_data));
usr_auth_data.paired_flag = 0;
syscfg_write(CFG_USER_PAIR_INFO, (u8 *)&usr_auth_data, sizeof(usr_auth_data));
usr_clear_plan();
usr_reset_device_sta();
//sys_timeout_add(NULL,cpu_reset,600);
}
extern void usr_set_adv_interval(u16 val);
extern u16 usr_get_adv_interval();
extern void ble_multi_trans_disconnect(void);
void usr_ble_adv_init();
void usr_goto_pair_mode()
{
ble_multi_trans_disconnect();
usr_clear_pair_info_noreset();
usr_var.usr_goto_pair=1;
_usr_module_cfg.local_moto_mode=3;
usr_var.usr_goto_pair = 1;
os_time_dly(5);
usr_ble_adv_init();
}
void usr_ble_adv_init()
{
int8_t txpower = 0;
uint8_t manucode[BLEPROTO_ADV_TLV_LENGTH_MANUCODE] = { 0 };
int8_t txpower = 0;
uint8_t manucode[BLEPROTO_ADV_TLV_LENGTH_MANUCODE] = {0};
uint8_t prodcode[BLEPROTO_ADV_TLV_LENGTH_PRODCODE] = {'C', 'B', 'C', '0'};
uint8_t gmac[6]={0};
uint8_t pcode[6]={'P','I','C','B','C','0'};
uint8_t gmac[6] = {0};
uint8_t pcode[6] = {'P', 'I', 'C', 'B', 'C', '0'};
usr_set_adv_interval(80);
if(usr_var.usr_ota_succ_flag)return;
//muti_adv_data
if(usr_var.usr_goto_pair)
{
usr_clear_pair_info_noreset();
printf("power on force to par flag= %d\n",usr_auth_data.paired_flag);
//if(usr_auth_data.paired_flag==0)
{
muti_adv_data_len=bleproto_advdata_encode4bind(muti_adv_data,txpower,manucode,pcode,prodcode);
}
usr_var.usr_adv_flag=1;
if (usr_var.usr_ota_succ_flag) {
return;
}
else
{
if (usr_var.usr_goto_pair) {
usr_clear_pair_info_noreset();
printf("power on force to pair flag= %d\n", usr_auth_data.paired_flag);
muti_adv_data_len = bleproto_advdata_encode4bind(muti_adv_data, txpower, manucode, pcode, prodcode);
usr_var.usr_adv_flag = 1;
} else {
usr_get_pair_info();
if(usr_auth_data.paired_flag==0)
{
muti_adv_data_len=bleproto_advdata_encode4bind(muti_adv_data,txpower,manucode,pcode,prodcode);
usr_var.usr_adv_flag=0;
}
else
{
memcpy(gmac,usr_auth_data.gwmac,6);
muti_adv_data_len=bleproto_advdata_encode4reconn(muti_adv_data,txpower,gmac,manucode,pcode,prodcode);
usr_var.usr_adv_flag=1;
if (usr_auth_data.paired_flag == 0) {
muti_adv_data_len = bleproto_advdata_encode4bind(muti_adv_data, txpower, manucode, pcode, prodcode);
usr_var.usr_adv_flag = 0;
} else {
memcpy(gmac, usr_auth_data.gwmac, 6);
muti_adv_data_len = bleproto_advdata_encode4reconn(muti_adv_data, txpower, gmac, manucode, pcode, prodcode);
usr_var.usr_adv_flag = 1;
}
}
usr_ble_adv_updata();
if(le_timer_handle==0)le_timer_handle = sys_timer_add(NULL, usr_ble_adv_updata, 500);
//user_send_cmd_prepare(USER_CTRL_ALL_SNIFF_EXIT, 0, NULL);
if (le_timer_handle == 0) {
le_timer_handle = sys_timer_add(NULL, usr_ble_adv_updata, 500);
}
}
u8 usr_get_pair_flag()
{
return usr_auth_data.paired_flag;
}
/*
void usr_reconn_adv()
{
int8_t txpower = 0;
uint8_t gmac[6]={0};
uint8_t manucode[BLEPROTO_ADV_TLV_LENGTH_MANUCODE] = { 0 };
uint8_t prodcode[BLEPROTO_ADV_TLV_LENGTH_PRODCODE] = {'C', 'B', 'F', 'D'};
uint8_t pcode[6]={'P','C','B','F','D','0'};
memcpy(gmac,usr_auth_data.gwmac,6);
muti_adv_data_len=bleproto_advdata_encode4reconn(muti_adv_data,txpower,gmac,manucode,pcode,prodcode);
usr_adv_flag=1;
}*/
extern u16 get_vbat_level(void);
extern void ble_trans_module_enable(u8 flag);
extern u8 usr_get_ota_status();
void usr_ble_adv_updata()
{
//printf("usr_ble_adv_updata\n");
static u16 usr_goto_slow_adv=0;
if(usr_var.usr_adv_flag)
{
static u16 usr_goto_slow_adv = 0;
if (usr_var.usr_adv_flag) {
ble_trans_module_enable(0);
usr_var.usr_adv_flag=0;
muti_make_set_adv_data(muti_adv_data,muti_adv_data_len);
usr_var.usr_adv_flag = 0;
muti_make_set_adv_data(muti_adv_data, muti_adv_data_len);
printf("###muti_adv_data = ");
printf_buf(muti_adv_data,muti_adv_data_len);
printf_buf(muti_adv_data, muti_adv_data_len);
ble_trans_module_enable(1);
}
if(usr_get_conn_service()==0)
{
if(usr_get_adv_interval()==80)
{
if((usr_var.usr_goto_pair==0)&&(usr_auth_data.paired_flag))
{
if(usr_var.usr_ota_succ_flag==0)
{
if (usr_get_conn_service() == 0) {
if (usr_get_adv_interval() == 80) {
if ((usr_var.usr_goto_pair == 0) && (usr_auth_data.paired_flag)) {
if (usr_var.usr_ota_succ_flag == 0) {
usr_goto_slow_adv++;
printf("usr_goto_slow_adv = %d\n",usr_goto_slow_adv);
}
if(usr_goto_slow_adv>=120)
{
usr_goto_slow_adv=0;
usr_set_adv_interval(80*10);
usr_var.usr_adv_flag=1;
if (usr_goto_slow_adv >= 120) {
usr_goto_slow_adv = 0;
usr_set_adv_interval(80 * 10);
usr_var.usr_adv_flag = 1;
}
}
} else {
usr_goto_slow_adv = 0;
}
else
{
usr_goto_slow_adv=0;
}
}
else
{
usr_goto_slow_adv=0;
} else {
usr_goto_slow_adv = 0;
}
if(usr_get_ota_status()==0)
{
if(usr_get_conn_service()==0)
{
if(usr_var.usr_ota_succ_flag==0)usr_ota_exit();
if (usr_get_ota_status() == 0) {
if (usr_get_conn_service() == 0) {
if (usr_var.usr_ota_succ_flag == 0) {
usr_ota_exit();
}
}
}
}
void usr_ble_adv_updata_OTA()
{
//printf("usr_ble_adv_updata\n");
if(1)
{
ble_trans_module_enable(0);
usr_var.usr_adv_flag=0;
ble_trans_module_enable(0);
usr_var.usr_adv_flag = 0;
#if 1
extern u8 usr_mac_addr[6];
//u8 ble_mac[6];
extern int le_controller_set_mac(void *addr);
//extern void lib_make_ble_address(u8 * ble_address, u8 * edr_address);
//bt_update_mac_addr(mac);
//lmp_hci_write_local_address(mac);
//bt_update_testbox_addr(mac);
//lib_make_ble_address(ble_mac, mac);
usr_mac_addr[0]=usr_mac_addr[0]+1;
le_controller_set_mac(usr_mac_addr); //修改BLE地址
extern u8 usr_mac_addr[6];
extern int le_controller_set_mac(void *addr);
usr_mac_addr[0] = usr_mac_addr[0] + 1;
le_controller_set_mac(usr_mac_addr);
#endif
muti_make_set_adv_data_updata();
printf("###muti_adv_data = ");
printf_buf(muti_adv_data,muti_adv_data_len);
ble_trans_module_enable(1);
}
muti_make_set_adv_data_updata();
printf("###muti_adv_data = ");
printf_buf(muti_adv_data, muti_adv_data_len);
ble_trans_module_enable(1);
}
apps/usr_le_code/usr_le_recieve.c
+59 -536
View File
@@ -1,4 +1,4 @@
#include "system/includes.h"
#include "system/includes.h"
#include "app_config.h"
#include "asm/pwm_led.h"
#include "tone_player.h"
@@ -29,7 +29,6 @@
#define FIRM_PACK_LEN 2048//128
extern u8 usr_we_plan_table[170];//[17];
static u8 start_data[10]={0x55,0xAA,0xFE,0x61,0x06,0x00,0x00,0x00,0x00,0x00};
static u8 end_data[2]={0xaa,0x55};
static int encode_len=0x00;
@@ -39,34 +38,19 @@ static u8 ota_source_data[FIRM_PACK_LEN*2]={0};
extern u16 usr_get_conn_service();
extern void usr_clear_up();
extern void ble_multi_trans_disconnect(void);
extern void usr_ble_adv_updata_OTA();
extern void usr_ble_send_data(u8* data,u16 len);///BLE发送接口，MTU 244
extern void usr_ble_send_data(u8* data,u16 len);
extern void usr_write_pair_info();
extern void usr_clear_pair_info();
extern void usr_write_plan(u8 write_num,u8*data);
extern void usr_read_plan();
extern void usr_clear_plan();
extern void usr_write_plan_to_vm();
extern void usr_set_werishi(int cnt,u8 weishi_type);
extern void usr_set_led_sta(u8 flag);
extern void app_audio_volume_set(u8 value);
extern int dual_ota_app_data_deal(u32 msg, u8 *buf, u32 len);
extern void usr_write_time_flag(u8 falg);
extern u8 usr_get_time_flag();
extern int uart_tr_send_data(u8 *data, u32 len);
extern void usr_set_data_time(int64_t timestampMs, int64_t timezoneOffset);
extern void usr_set_device_default();
extern void usr_intterupt_close();
extern int dual_ota_app_data_deal(u32 msg, u8 *buf, u32 len);
extern int uart_tr_send_data(u8 *data, u32 len);
void usr_ota_deal_task();
void usr_le_notify_data();
void usr_data_ana(bleproto_appdata_desc_t *desc);
void usr_do_action_code(int flag);
void usr_run_cmd_code(bleproto_runcmd_req_t* runcmd_par,u8 usr_msg_id);
void usr_app_ota_init();
void usr_data_notify_auto();
void usr_test_protocol(void);
bleproto_authsetup_req_t usr_auth_data;
@@ -75,59 +59,32 @@ usr_module_cfg_cache _usr_module_cfg_cache;
void usr_read_device_sta()
{
int ret = 0xff;
ret=syscfg_read(CFG_USER_DEVICE_STA, (u8 *)&_usr_module_cfg, sizeof(_usr_module_cfg));
if(ret<=0)
{
_usr_module_cfg.local_moto_mode=1;
_usr_module_cfg.usr_dizhuo_mode=0;
_usr_module_cfg.usr_douban_mode=0;
_usr_module_cfg.power_on_flag =1;
_usr_module_cfg.zhengdong_kaiji=0;
_usr_module_cfg.wuraomoshi_onoff=0;
int ret = syscfg_read(CFG_USER_DEVICE_STA, (u8 *)&_usr_module_cfg, sizeof(_usr_module_cfg));
if (ret <= 0) {
memset(&_usr_module_cfg, 0, sizeof(_usr_module_cfg));
_usr_module_cfg.power_on_flag = 1;
syscfg_write(CFG_USER_DEVICE_STA, (u8 *)&_usr_module_cfg, sizeof(_usr_module_cfg));
}
_usr_module_cfg.usr_dizhuo_mode=0;
_usr_module_cfg.usr_douban_mode=0;
// _usr_module_cfg.local_moto_mode=1;
_usr_module_cfg.power_on_flag =1;
//memcpy(&_usr_module_cfg_cache,&_usr_module_cfg,sizeof(_usr_module_cfg));
_usr_module_cfg_cache.local_moto_mode=0xff;
_usr_module_cfg_cache.usr_dizhuo_mode=0xff;
_usr_module_cfg_cache.usr_douban_mode=0xff;
_usr_module_cfg_cache.power_on_flag =0x01;
_usr_module_cfg.power_on_flag = 1;
memset(&_usr_module_cfg_cache, 0xff, sizeof(_usr_module_cfg_cache));
_usr_module_cfg_cache.power_on_flag = 0x01;
}
void usr_reset_device_sta()
{
int ret = 0xff;
_usr_module_cfg.local_moto_mode=1;
_usr_module_cfg.usr_dizhuo_mode=0;
_usr_module_cfg.usr_douban_mode=0;
_usr_module_cfg.power_on_flag =1;
_usr_module_cfg.zhengdong_kaiji=0;
_usr_module_cfg.wuraomoshi_onoff=0;
ret = syscfg_write(CFG_USER_DEVICE_STA, (u8 *)&_usr_module_cfg, sizeof(_usr_module_cfg));
printf("############# ret = %d _usr_module_cfg.zhengdong_kaiji = %d\n",ret,_usr_module_cfg.zhengdong_kaiji);
memset(&_usr_module_cfg, 0, sizeof(_usr_module_cfg));
_usr_module_cfg.power_on_flag = 1;
syscfg_write(CFG_USER_DEVICE_STA, (u8 *)&_usr_module_cfg, sizeof(_usr_module_cfg));
}
void usr_write_device_sta_vm()
{
int ret = 0xff;
ret=syscfg_write(CFG_USER_DEVICE_STA, (u8 *)&_usr_module_cfg, sizeof(_usr_module_cfg));
usr_le_notify_data();
memcpy(&_usr_module_cfg_cache,&_usr_module_cfg,sizeof(_usr_module_cfg));
//printf("usr_write_device_sta_vm\n");
syscfg_write(CFG_USER_DEVICE_STA, (u8 *)&_usr_module_cfg, sizeof(_usr_module_cfg));
memcpy(&_usr_module_cfg_cache, &_usr_module_cfg, sizeof(_usr_module_cfg));
}
void usr_write_device_sta()
{
// io_ext_interrupt_close(0, IO_PORTA_01);
usr_write_device_sta_vm();
}
@@ -140,41 +97,32 @@ void usr_le_data_recieve(u8* data,u16 len)///BLE数据接收
int rc_result=0;
if(_usr_module_cfg.local_moto_mode==3)_usr_module_cfg.local_moto_mode=0;
memcpy(&rxbuf[usr_len],data,len);
usr_len+=len;
rc_result = bleproto_appdata_decode(rxbuf, usr_len, &desc);
// printf("rc_result_le## = %d\n",rc_result);
if(rc_result < 0)
{
// 接收到了非法的数据包，无法解析
usr_len=0;
}
else if(rc_result == 0)
{
// 接收的数据不完整，继续接收数据
/* incomplete frame */
}
else //(rc_result > 0)
else
{
// 数据解析成功
usr_len=0;
usr_data_ana(&desc);
}
//usr_ble_send_data(data,len);
}
#if 1
void usr_send_ble_sta(u8 flag)
{
(void)flag;
}
void usr_set_device_default()
{
}
void usr_data_ana(bleproto_appdata_desc_t *desc)
@@ -192,8 +140,9 @@ void usr_data_ana(bleproto_appdata_desc_t *desc)
encode_desc.header.encrypt = 0;
encode_desc.header.serviceid = E_BLEPROTO_SERVICE_ID_DEVICEINFO;
usr_set_data_time(desc->datast.deviceinfo_req.t,desc->datast.deviceinfo_req.gmtoff);
/* deviceinfo 时间字段忽略：桥接板无 RTC/计划业务 */
(void)desc->datast.deviceinfo_req.t;
(void)desc->datast.deviceinfo_req.gmtoff;
//deviceinfo rsp序列化
bleproto_deviceinfo_rsp_t *rsp = &encode_desc.datast.deviceinfo_rsp;
{
@@ -287,43 +236,29 @@ void usr_data_ana(bleproto_appdata_desc_t *desc)
printf("2encode_len = %d\n",encode_len);
}
break;
case E_BLEPROTO_SERVICE_ID_RUNCMD:
// 设备处理，回复响应
printf("E_BLEPROTO_SERVICE_ID_RUNCMD\n");
usr_run_cmd_code(&desc->datast.runcmd_req,desc->header.msgid);
break;
case E_BLEPROTO_SERVICE_ID_DOACTION:
printf("E_BLEPROTO_SERVICE_ID_DOACTION\n");
encode_desc.header.version = 0;
encode_desc.header.datafmt = BLEPROTO_APPDATA_DATAFMT_JSON;
encode_desc.header.msgtype = BLEPROTO_APPDATA_MSGTYPE_RSP;
encode_desc.header.msgid = desc->header.msgid;//这里的msg_id为上面解析到的包的msg_id;
encode_desc.header.msgid = desc->header.msgid;
encode_desc.header.encrypt = 0;
encode_desc.header.serviceid = E_BLEPROTO_SERVICE_ID_DOACTION;
encode_desc.datast.doaction_rsp.errcode = 0;
bleproto_doaction_rsp_t *action_rsp = &encode_desc.datast.doaction_rsp;
encode_desc.datast.doaction_rsp.errcode = 0;
{
action_rsp->errcode=0;
// 执行命令
printf("action_run %d \n",desc->datast.doaction_req.action);
bleproto_doaction_rsp_t *action_rsp = &encode_desc.datast.doaction_rsp;
action_rsp->errcode = 0;
printf("action_run %d \n", desc->datast.doaction_req.action);
}
encode_len = bleproto_appdata_encode(txbuf, sizeof(txbuf), sizeof(txbuf), &encode_desc);
if(encode_len > 0) {
printf("encode_len = %d\n",encode_len);
usr_ble_send_data(txbuf,encode_len);
if (encode_len > 0) {
usr_ble_send_data(txbuf, encode_len);
usr_do_action_code(desc->datast.doaction_req.action);
}
else
{
printf("2encode_len = %d\n",encode_len);
}
break;
case E_BLEPROTO_SERVICE_ID_OTANOTIFY:
printf("E_BLEPROTO_SERVICE_ID_OTANOTIFY\n");
_usr_module_cfg.local_moto_mode=3;
encode_desc.header.version = 0;
encode_desc.header.datafmt = BLEPROTO_APPDATA_DATAFMT_JSON;
encode_desc.header.msgtype = BLEPROTO_APPDATA_MSGTYPE_RSP;
@@ -558,234 +493,42 @@ void usr_ota_deal_task()
#endif // 0
void usr_run_cmd_code(bleproto_runcmd_req_t* runcmd_par,u8 usr_msg_id)
{
printf("runcmd_par id = %d\n",runcmd_par->ycmd.cmd_id);
bleproto_appdata_desc_t encode_desc = { 0 };
encode_desc.header.version = 0;
encode_desc.header.datafmt = BLEPROTO_APPDATA_DATAFMT_JSON;
encode_desc.header.msgtype = BLEPROTO_APPDATA_MSGTYPE_RSP;
encode_desc.header.msgid = usr_msg_id;
encode_desc.header.encrypt = 0;
encode_desc.header.serviceid = E_BLEPROTO_SERVICE_ID_RUNCMD;
bleproto_runcmd_rsp_t *rsp = &encode_desc.datast.runcmd_rsp;
switch(runcmd_par->ycmd.cmd_id)
{
case 202:
printf("runcmd_par->ycmd.arg_int32 0 = %d\n",runcmd_par->ycmd.arg_int32[0]);
rsp->ycmd.cmd_id = 110;
rsp->ycmd.arg_int32_count = 2;
rsp->ycmd.arg_string_count = 0;
rsp->ycmd.arg_bytes_count = 0;
/*
| 索引 | 类型 | 描述 | 取值 |
| ---- | ----- | ---------- | ---------------- |
| 0 | int32 | 开关机控制 | 0：关机；1：开机 |
*/
if(runcmd_par->ycmd.arg_int32[0]==0)//关机
{
_usr_module_cfg.power_on_flag=0;
usr_var.usr_intterupt_reinit_falg=1;
usr_intterupt_close();
}
else //开机
{
_usr_module_cfg.power_on_flag=1;
}
usr_clear_up();
rsp->ycmd.arg_int32[0] = 202;
rsp->ycmd.arg_int32[1] = 0;
rsp->ycmd.t = usr_var.usr_cureent_utc;
usr_var.usr_allow_to_sleep_cnt=8;
usr_write_device_sta();
break;
case 203:
/*
| 索引 | 类型 | 描述 | 取值 |
| ---- | ----- | ------------------ | ----------------------------------------------------------------- |
| 0 | int32 | 运动模式 | 0：关闭内置模式；1-鸡血，2-佛系 |
| 1 | int32 | 底座转动模式 | 0：关闭；1：平稳；2：狂转 |
| 2 | int32 | 逗猫棒摇动模式 | 0：关闭；1：自动; 2：转圈; 3:抖动; |
| 3 | int32 | 逗猫棒手动参数 | 逗猫棒摇动模式为0时有效, 0：无效；1:手动正转一圈 ；2:手动正转一圈 |
*/
usr_var.usr_allow_to_sleep_cnt=8;
_usr_module_cfg.local_moto_mode=runcmd_par->ycmd.arg_int32[0];
_usr_module_cfg.usr_dizhuo_mode=runcmd_par->ycmd.arg_int32[1];
_usr_module_cfg.usr_douban_mode=runcmd_par->ycmd.arg_int32[2];
_usr_module_cfg.usr_doumaoshoudong=runcmd_par->ycmd.arg_int32[3];
rsp->ycmd.cmd_id = 110;
rsp->ycmd.arg_int32_count = 2;
rsp->ycmd.arg_string_count = 0;
rsp->ycmd.arg_bytes_count = 0;
rsp->ycmd.arg_int32[0] = 203;
rsp->ycmd.arg_int32[1] = 0;
rsp->ycmd.t = usr_var.usr_cureent_utc;
usr_clear_up();
usr_write_device_sta();
break;
case 206:///震动开机参数配置
/*
| 索引 | 类型 | 描述 | 取值 |
| ---- | ------ | ------------------------------------------------------------ | ----------------------------- |
| 0 | int32 | 震动开机开关 | -1:忽略， 0：关闭；1：开启 |
| 1 | int32 | 勿扰模式开关 | -1:忽略， 0：关闭；1：开启 |
| 0 | string | 周计划 + 开始时间点 + 结束时间点<br />周计划：dddddd,
从左到右表示7个，分别表示周一到周日，1表示有效，0表示无效 <br />
时间点：hhmm, hh表示小时，mm表示分钟<br />
例如<br />0
0000001+1828+1930 表示每周日重复+18:28开始+19:30结束<br />
1000001+0928+1930 表示每周一和周日重复+09:28开始+19:30结束<br />
1100000+1328+1930 表示每周一和周二重复+13:28开始+19:30结束<br / | 字符串<br />ddddddd+hhmm+hhmm |
*/
_usr_module_cfg.zhengdong_kaiji=runcmd_par->ycmd.arg_int32[0];
_usr_module_cfg.wuraomoshi_onoff=runcmd_par->ycmd.arg_int32[1];
printf("zhengdong_kaiji = %d wuraomoshi_onoff = %d\n",_usr_module_cfg.zhengdong_kaiji,_usr_module_cfg.wuraomoshi_onoff);
printf("arg_string_count = %d\n",runcmd_par->ycmd.arg_string_count);
//printf("string = %s\n",&rsp->ycmd.arg_string[0][0],17);
if(runcmd_par->ycmd.arg_string_count)
{
usr_clear_plan();
for(u8 i=0;i<runcmd_par->ycmd.arg_string_count;i++)
{
usr_write_plan(i,&runcmd_par->ycmd.arg_string[i][0]);
}
usr_write_plan_to_vm();
usr_read_plan();
}
usr_write_device_sta();
rsp->ycmd.cmd_id = 110;
rsp->ycmd.arg_int32_count = 2;
rsp->ycmd.arg_bytes_count = 0;
rsp->ycmd.arg_int32[0] = 206;
rsp->ycmd.arg_int32[1] = 0;
rsp->ycmd.t = usr_var.usr_cureent_utc;
break;
case 207:///周计划查询
rsp->ycmd.cmd_id = 110;
rsp->ycmd.arg_int32_count = 4;
rsp->ycmd.arg_bytes_count = 0;
rsp->ycmd.arg_string_count = usr_var.usr_plan_cnt;
rsp->ycmd.arg_int32[0] = 207;
rsp->ycmd.arg_int32[1] = 0;
rsp->ycmd.arg_int32[2] = _usr_module_cfg.zhengdong_kaiji;
rsp->ycmd.arg_int32[3] = _usr_module_cfg.wuraomoshi_onoff;
rsp->ycmd.t = usr_var.usr_cureent_utc;
for(u8 i=0;i<usr_var.usr_plan_cnt;i++)
{
memcpy(&rsp->ycmd.arg_string[i][0],&usr_we_plan_table[i*17],17);
}
break;
case 600:
/*
| 索引 | 类型 | 描述 | 取值 |
| ---- | ----- | ---------------- | ------------------------------------------------- |
| 0 | int32 | cmdid | 600 |
| 1 | int32 | 返回值 | 0: 设备接受命令成功; 非零: 参见具体的命令错误代码 |
| 2 | int32 | 当前电量 | [1, 100]：百分比；0：不使用电池供电 |
| 3 | int32 | 当前电量是否正常 | 0：正常；1：电量过低 |
| 4 | int32 | 充电状态 | 0: 不支持充电； 1：充电 2：未充电 |
| 5 | int32 | 开机状态 | 0：关闭；1：开启 |
| 6 | int32 | 运动模式 | 0：关闭；1：鸡血；2：佛系 |
| 7 | int32 | 底座转动模式 | 0：关闭；1：平稳；2：狂转 |
| 8 | int32 | 逗猫棒摇动模式 | 0：手动；1：自动；2：转圈；3：抖动 |
*/
rsp->ycmd.cmd_id = 110;
rsp->ycmd.arg_int32_count = 9;
rsp->ycmd.arg_string_count = 0;
rsp->ycmd.arg_bytes_count = 0;
rsp->ycmd.arg_int32[0] = 600;
rsp->ycmd.arg_int32[1] = 0; //0：命令接收成功
rsp->ycmd.arg_int32[2] = usr_var.usr_bat_level; // 电量上报
if(usr_var.usr_bat_level<30)rsp->ycmd.arg_int32[3] = 1;
else rsp->ycmd.arg_int32[3] = 0; // 当前电量是否正常
rsp->ycmd.arg_int32[4] = usr_var.usr_power_charge_flag; // 充电状态
rsp->ycmd.arg_int32[5] = _usr_module_cfg.power_on_flag; // 开机状态
rsp->ycmd.arg_int32[6] = _usr_module_cfg.local_moto_mode; // 运动模式
rsp->ycmd.arg_int32[7] = _usr_module_cfg.usr_dizhuo_mode; // 底座运动模式
rsp->ycmd.arg_int32[8] = _usr_module_cfg.usr_douban_mode; // 逗猫棒摇动模式
rsp->ycmd.t = usr_var.usr_cureent_utc; // UTC时间戳;
memcpy(&_usr_module_cfg_cache,&_usr_module_cfg,sizeof(_usr_module_cfg));
break;
default:
break;
}
int encode_len = bleproto_appdata_encode(
/* txbuf */ txbuf,
/* size */ sizeof(txbuf),
/* packetlen */ sizeof(txbuf),
/* desc */ &encode_desc);
printf("encode_len = %d\n",encode_len);
if(encode_len > 0)
{
usr_ble_send_data(txbuf,encode_len);
}
else
{
}
}
void usr_ota_process()
{
static u8 cnt=0;
if(cnt==0)
{
static u8 cnt = 0;
if (cnt == 0) {
ble_multi_trans_disconnect();
}
if(usr_get_conn_service()==0)
{
if (usr_get_conn_service() == 0) {
cnt++;
if(cnt==2)
{
if (cnt == 2) {
usr_ble_adv_updata_OTA();
}
if(cnt>=60)
{
cnt=0;
if (cnt >= 60) {
cnt = 0;
cpu_reset();
}
} else {
cnt = 1;
}
else
{
cnt=1;
}
}
void usr_do_action_code(int flag)
{
switch(flag)
{
case 0:///重启
switch (flag) {
case 0: /* reboot */
cpu_reset();
break;
case 1:///指示-identify；收到命令设备led闪烁或者喇叭发音，指示设备存在
// app_task_put_key_msg(KEY_IR_NUM_1, 0);
break;
case 2:///回复出厂设置-reset；蓝牙连接信息也需要清除
case 2: /* factory reset, clear pair */
usr_set_device_default();
usr_clear_pair_info();
break;
case 3:///清空配置-clear，保留蓝牙连接信息
case 3: /* clear cfg, keep pair */
usr_set_device_default();
break;
case 100:
_usr_module_cfg.local_moto_mode=3;
case 100: /* enter OTA */
usr_app_ota_init();
break;
default:
@@ -795,256 +538,36 @@ void usr_do_action_code(int flag)
void usr_app_ota_init()
{
usr_var.usr_goto_updata=1;
if(usr_var.ota_timer==0)
{
usr_var.ota_timer=sys_timer_add(NULL,usr_ota_process,1000);
usr_var.usr_goto_updata = 1;
if (usr_var.ota_timer == 0) {
usr_var.ota_timer = sys_timer_add(NULL, usr_ota_process, 1000);
}
}
void usr_le_notify_data()
{
//设备状态变化可向主控设备上报数据
if(usr_get_conn_service()==0)return;
printf("usr_le_notify_data cmdid1 = 100\n");
// 测试数据
bleproto_appdata_desc_t encode_desc = { 0 };
encode_desc.header.version = 0;
encode_desc.header.datafmt = BLEPROTO_APPDATA_DATAFMT_JSON;
encode_desc.header.msgtype = BLEPROTO_APPDATA_MSGTYPE_REQ;
encode_desc.header.msgid = 1;
encode_desc.header.encrypt = 0;
encode_desc.header.serviceid = E_BLEPROTO_SERVICE_ID_REPORTCMD;
// 每次上报都需要填写以下所有内容
bleproto_reportcmd_req_t *req = &encode_desc.datast.reportcmd_req;
{
/*
| 索引 | 类型 | 描述 | 取值 |
| ---- | ----- | ---------------- | ----------------------------------------------------- |
| 0 | int32 | 当前电量 | [1, 100]：百分比；0：不使用电池供电，无变化填写888888 |
| 1 | int32 | 当前电量是否正常 | 0：正常；1：电量过低，无变化填写888888 |
| 2 | int32 | 充电状态 | 0: 不支持充电； 1：充电 2：未充电，无变化填写888888 |
| 3 | int32 | 开机状态 | 0：关闭；1：开启，无变化填写888888 |
| 4 | int32 | 运动模式 | 0：关闭；1：鸡血；2：佛系，无变化填写888888 |
| 5 | int32 | 底座转动模式 | 0：关闭；1：平稳；2：狂转，无变化填写888888 |
| 6 | int32 | 逗猫棒摇动模式 | 0：关闭；1：自动；2：转圈；3：抖动，无变化填写888888 |
| 7 | int32 | UTC时间戳 | 单位秒 |
*/
req->ycmd.cmd_id = 100;
req->ycmd.arg_int32[0] = usr_var.usr_bat_level;// 电量上报
if(usr_var.usr_bat_level<30)req->ycmd.arg_int32[1] = 1;
else req->ycmd.arg_int32[1] = 0; // 当前电量是否正常
req->ycmd.arg_int32[2] = usr_var.usr_power_charge_flag;// 充电状态
req->ycmd.arg_int32[3] = _usr_module_cfg.power_on_flag;// 开机状态
req->ycmd.arg_int32[4] = _usr_module_cfg.local_moto_mode;
req->ycmd.arg_int32[5] = _usr_module_cfg.usr_dizhuo_mode;// 底座运动模式
req->ycmd.arg_int32[6] = _usr_module_cfg.usr_douban_mode;// 逗猫棒运动模式
req->ycmd.arg_int32[7] = usr_var.usr_cureent_utc;// UTC时间戳
if(_usr_module_cfg_cache.power_on_flag==_usr_module_cfg.power_on_flag)
{
req->ycmd.arg_int32[3] = 888888; // 运动模式
}
if(_usr_module_cfg_cache.local_moto_mode==_usr_module_cfg.local_moto_mode)
{
req->ycmd.arg_int32[4] = 888888; // 运动模式
}
if(_usr_module_cfg_cache.usr_dizhuo_mode==_usr_module_cfg.usr_dizhuo_mode)
{
req->ycmd.arg_int32[5] = 888888; // 底座运动模式
}
if(_usr_module_cfg_cache.usr_douban_mode==_usr_module_cfg.usr_douban_mode)
{
req->ycmd.arg_int32[6] = 888888; // 逗猫棒运动模式
}
req->ycmd.arg_int32_count = 8;
req->ycmd.t = usr_var.usr_cureent_utc;
memcpy(&_usr_module_cfg_cache,&_usr_module_cfg,sizeof(_usr_module_cfg));
}
int encode_len = bleproto_appdata_encode(
/* txbuf */ txbuf,
/* size */ sizeof(txbuf),
/* packetlen */ sizeof(txbuf),
/* desc */ &encode_desc);
printf("encode_len = %d\n",encode_len);
if(encode_len > 0)
{
usr_ble_send_data(txbuf,encode_len);
}
else
{
}
}
void usr_le_120_notify_data()
{
//设备状态变化可向主控设备上报数据
if(usr_get_conn_service()==0)return;
printf("usr_le_notify_data cmdid1 = 120\n");
// 测试数据
bleproto_appdata_desc_t encode_desc = { 0 };
encode_desc.header.version = 0;
encode_desc.header.datafmt = BLEPROTO_APPDATA_DATAFMT_JSON;
encode_desc.header.msgtype = BLEPROTO_APPDATA_MSGTYPE_REQ;
encode_desc.header.msgid = 1;
encode_desc.header.encrypt = 0;
encode_desc.header.serviceid = E_BLEPROTO_SERVICE_ID_REPORTCMD;
// 每次上报都需要填写以下所有内容
bleproto_reportcmd_req_t *req = &encode_desc.datast.reportcmd_req;
{
/*
> 告警上报 （*设备主动上报*）
* 命令ID： 120
* 参数说明
| 索引 | 类型 | 描述 | 取值 |
| ---- | ----- | ---------- | ----------------------------------------------------- |
| 0 | int32 | 告警事件id | 5000：硬件故障；5001：低电量报警; 5010：震动开机报警 |
| 1 | int32 | UTC时间戳 | 事件触发UTCS时间戳单位秒 |
*/
req->ycmd.cmd_id = 120;
req->ycmd.arg_int32[0] = 5010;//
req->ycmd.arg_int32[1] = usr_var.usr_cureent_utc;// UTC时间戳
req->ycmd.arg_int32_count = 2;
req->ycmd.t = usr_var.usr_cureent_utc;
}
int encode_len = bleproto_appdata_encode(
/* txbuf */ txbuf,
/* size */ sizeof(txbuf),
/* packetlen */ sizeof(txbuf),
/* desc */ &encode_desc);
printf("encode_len = %d\n",encode_len);
if(encode_len > 0)
{
usr_ble_send_data(txbuf,encode_len);
}
else
{
}
}
void usr_le_low_power_notify()
{
//设备状态变化可向主控设备上报数据
if(usr_get_conn_service()==0)return;
printf("usr_le_notify_data cmdid2 = 120\n");
// 测试数据
bleproto_appdata_desc_t encode_desc = { 0 };
encode_desc.header.version = 0;
encode_desc.header.datafmt = BLEPROTO_APPDATA_DATAFMT_JSON;
encode_desc.header.msgtype = BLEPROTO_APPDATA_MSGTYPE_REQ;
encode_desc.header.msgid = 1;
encode_desc.header.encrypt = 0;
encode_desc.header.serviceid = E_BLEPROTO_SERVICE_ID_REPORTCMD;
// 每次上报都需要填写以下所有内容
bleproto_reportcmd_req_t *req = &encode_desc.datast.reportcmd_req;
{
/*
> 告警上报 （*设备主动上报*）
* 命令ID： 120
* 参数说明
| 索引 | 类型 | 描述 | 取值 |
| ---- | ----- | ---------- | ----------------------------------------------------- |
| 0 | int32 | 告警事件id | 5000：硬件故障；5001：低电量报警; 5010：震动开机报警 |
| 1 | int32 | UTC时间戳 | 事件触发UTCS时间戳单位秒 |
*/
req->ycmd.cmd_id = 120;
req->ycmd.arg_int32[0] = 5001;// 电量上报
req->ycmd.arg_int32[1] = usr_var.usr_cureent_utc;// UTC时间戳
req->ycmd.arg_int32_count = 2;
req->ycmd.t = usr_var.usr_cureent_utc;
}
int encode_len = bleproto_appdata_encode(
/* txbuf */ txbuf,
/* size */ sizeof(txbuf),
/* packetlen */ sizeof(txbuf),
/* desc */ &encode_desc);
printf("encode_len = %d\n",encode_len);
if(encode_len > 0)
{
usr_ble_send_data(txbuf,encode_len);
}
else
{
}
}
u8 usr_weishi_type=0;
u8 usr_weishi_index=0;
u8 usr_weishi_fenshu=1;
void usr_weishi_notify()
{
}
void usr_data_notify_auto()
{
// sys_timeout_add(NULL,usr_le_notify_data,500);
// usr_le_notify_data();
}
void usr_test_protocol(void)
{
bleproto_appdata_desc_t encode_desc = { 0 };
encode_desc.header.version = 0;
encode_desc.header.datafmt = BLEPROTO_APPDATA_DATAFMT_JSON;
encode_desc.header.msgtype = BLEPROTO_APPDATA_MSGTYPE_REQ;
encode_desc.header.msgid = 1;
encode_desc.header.encrypt = 0;
encode_desc.header.serviceid = E_BLEPROTO_SERVICE_ID_REPORTCMD_V2;
bleproto_appdata_desc_t encode_desc = {0};
encode_desc.header.version = 0;
encode_desc.header.datafmt = BLEPROTO_APPDATA_DATAFMT_JSON;
encode_desc.header.msgtype = BLEPROTO_APPDATA_MSGTYPE_REQ;
encode_desc.header.msgid = 1;
encode_desc.header.encrypt = 0;
encode_desc.header.serviceid = E_BLEPROTO_SERVICE_ID_REPORTCMD_V2;
ble_proto_packet_t *pkt = &encode_desc.datast.runcmd_v2_req;
uint8_t test_data[9] = {0x55,0xAA,0x00,0x05,0x07,0x00,0x01,0x01,0x0E};
uint8_t test_data[9] = {0x55, 0xAA, 0x00, 0x05, 0x07, 0x00, 0x01, 0x01, 0x0E};
pkt->cmd = 100;
pkt->reserved = 0;
pkt->gateway_int_cnt = 0;
pkt->device_int_len = 0;
pkt->device_str_len = 0;
pkt->device_bytes_len = 9;
pkt->bytes_data = (uint8_t*)test_data;
pkt->bytes_data = (uint8_t *)test_data;
int encode_len = bleproto_appdata_encode(
/* txbuf */ txbuf,
/* size */ sizeof(txbuf),
/* packetlen */ sizeof(txbuf),
/* desc */ &encode_desc);
printf("encode_len = %d\n",encode_len);
if(encode_len > 0)
{
usr_ble_send_data(txbuf,encode_len);
printf("txbuf = ");
printf_buf(txbuf, encode_len);
int elen = bleproto_appdata_encode(txbuf, sizeof(txbuf), sizeof(txbuf), &encode_desc);
printf("encode_len = %d\n", elen);
if (elen > 0) {
usr_ble_send_data(txbuf, elen);
printf_buf(txbuf, elen);
}
}
apps/usr_moto/usr_moto_work.c
-609
View File
@@ -1,609 +0,0 @@
#include "system/includes.h"
#include "app_config.h"
#include "asm/pwm_led.h"
#include "tone_player.h"
#include "ui_manage.h"
#include "app_main.h"
#include "app_task.h"
#include "asm/charge.h"
#include "app_power_manage.h"
#include "app_charge.h"
#include "user_cfg.h"
#include "audio.h"
#include "vm.h"
#include "sys_time.h"
extern void usr_set_up_moto(u8 dir,u16 duty);
extern void usr_set_down_moto(u8 dir,u16 duty);
extern void io_ext_interrupt_test(void);
extern void usr_intterupt_close();
extern void usr_le_120_notify_data();
extern void usr_write_device_sta();
extern void usr_pwm_reinit();
void usr_moto_main();
void usr_moto_timer_init()
{
usr_var.usr_intterupt_reinit_falg=1;
usr_var.usr_auto_off_cnt=0;
io_ext_interrupt_test();
usr_intterupt_close();
_usr_module_cfg.power_on_flag=1;
}
#define HIG_DUTY 90
#define LOW_DUTY 50
#define OFF_DUTY 0
#define DIR_L 1
#define DIR_R 2
#define DIR_F 0
/*
// 模式切换中断服务函数
void modeSwitchISR() interrupt 0 {
modeDirection = !modeDirection; // 切换方向
while(!MODE_SWITCH); // 等待按键释放
}
*/
// 定义模式枚举
typedef enum {
MODE_1,
MODE_2,
MODE_3,
MODE_COUNT
} MotorMode;
// 定义状态枚举
typedef enum {
STATE_IDLE,
STATE_FORWARD,
STATE_REVERSE,
STATE_STOP
} MotorState;
// 全局变量
MotorMode currentMode = MODE_1;
u8 modeDirection = 1; // 1为正序，0为反序
MotorState currentState = STATE_IDLE;
unsigned int timerCount = 0;
unsigned int stepCount = 0;
// 马达正转
void motorForward() {
usr_set_up_moto(2,LOW_DUTY);
currentState = STATE_FORWARD;
}
// 马达反转
void motorReverse() {
usr_set_up_moto(1,LOW_DUTY);
currentState = STATE_REVERSE;
}
// 马达停止
void motorStop() {
usr_set_up_moto(0,OFF_DUTY);
currentState = STATE_STOP;
}
void usr_up_moto_mode()
{
if((_usr_module_cfg.local_moto_mode==1)||(_usr_module_cfg.local_moto_mode==2))
{
timerCount++;
// 模式1：正转3秒(6个周期)，反转3秒(6个周期)
if(currentMode == MODE_1) {
if(timerCount <= 6) {
motorForward();
} else if(timerCount <= 12) {
motorReverse();
} else {
timerCount = 0;
// 切换到下一个模式
if(modeDirection) {
currentMode = (currentMode + 1) % MODE_COUNT;
} else {
currentMode = (currentMode == 0) ? MODE_COUNT - 1 : currentMode - 1;
}
}
}
// 模式2：正转1秒(2个周期)停1秒(2个周期)，再正1秒停1秒，反转1秒停1秒，再正转1秒停1秒
else if(currentMode == MODE_2) {
switch(stepCount) {
case 0: case 1: // 正转1秒
motorForward();
if(timerCount % 2 == 0) stepCount++;
break;
case 2: case 3: // 停止1秒
motorStop();
if(timerCount % 2 == 0) stepCount++;
break;
case 4: case 5: // 正转1秒
motorForward();
if(timerCount % 2 == 0) stepCount++;
break;
case 6: case 7: // 停止1秒
motorStop();
if(timerCount % 2 == 0) stepCount++;
break;
case 8: case 9: // 反转1秒
motorReverse();
if(timerCount % 2 == 0) stepCount++;
break;
case 10: case 11: // 停止1秒
motorStop();
if(timerCount % 2 == 0) stepCount++;
break;
case 12: case 13: // 正转1秒
motorForward();
if(timerCount % 2 == 0) stepCount++;
break;
case 14: case 15: // 停止1秒
motorStop();
if(timerCount % 2 == 0) {
stepCount = 0;
timerCount = 0;
// 切换到下一个模式
if(modeDirection) {
currentMode = (currentMode + 1) % MODE_COUNT;
} else {
currentMode = (currentMode == 0) ? MODE_COUNT - 1 : currentMode - 1;
}
}
break;
}
}
// 模式3：连续4次，每次转500ms(1个周期)停1秒(2个周期)
else if(currentMode == MODE_3) {
if(stepCount < 8) { // 总共8个步骤（4次转停）
if(stepCount % 2 == 0) { // 奇数步骤：转500ms
motorForward();
} else { // 偶数步骤：停1秒
motorStop();
}
stepCount++;
} else {
stepCount = 0;
timerCount = 0;
// 切换到下一个模式
if(modeDirection) {
currentMode = (currentMode + 1) % MODE_COUNT;
} else {
currentMode = (currentMode == 0) ? MODE_COUNT - 1 : currentMode - 1;
}
}
}
usr_var.usr_auto_off_cnt++;
if(usr_var.usr_auto_off_cnt>=1200)
{
usr_var.usr_auto_off_cnt=0;
_usr_module_cfg.local_moto_mode=0;
//_usr_module_cfg.power_on_flag=0;
}
}
else
{
//if(_usr_module_cfg.local_moto_mode==0)
//{
usr_var.usr_auto_off_cnt=0;
//}
//else
//{
//}
}
}
void usr_up_moto_mode2()
{
timerCount++;
// 模式1：正转3秒(6个周期)，反转3秒(6个周期)
if(currentMode == MODE_1) {
if(timerCount <= 6) {
motorForward();
} else if(timerCount <= 12) {
motorReverse();
} else {
timerCount = 0;
// 切换到下一个模式
if(modeDirection) {
currentMode = (currentMode + 1) % MODE_COUNT;
} else {
currentMode = (currentMode == 0) ? MODE_COUNT - 1 : currentMode - 1;
}
}
}
// 模式2：正转1秒(2个周期)停1秒(2个周期)，再正1秒停1秒，反转1秒停1秒，再正转1秒停1秒
else if(currentMode == MODE_2) {
switch(stepCount) {
case 0: case 1: // 正转1秒
motorForward();
if(timerCount % 2 == 0) stepCount++;
break;
case 2: case 3: // 停止1秒
motorStop();
if(timerCount % 2 == 0) stepCount++;
break;
case 4: case 5: // 正转1秒
motorForward();
if(timerCount % 2 == 0) stepCount++;
break;
case 6: case 7: // 停止1秒
motorStop();
if(timerCount % 2 == 0) stepCount++;
break;
case 8: case 9: // 反转1秒
motorReverse();
if(timerCount % 2 == 0) stepCount++;
break;
case 10: case 11: // 停止1秒
motorStop();
if(timerCount % 2 == 0) stepCount++;
break;
case 12: case 13: // 正转1秒
motorForward();
if(timerCount % 2 == 0) stepCount++;
break;
case 14: case 15: // 停止1秒
motorStop();
if(timerCount % 2 == 0) {
stepCount = 0;
timerCount = 0;
// 切换到下一个模式
if(modeDirection) {
currentMode = (currentMode + 1) % MODE_COUNT;
} else {
currentMode = (currentMode == 0) ? MODE_COUNT - 1 : currentMode - 1;
}
}
break;
}
}
// 模式3：连续4次，每次转500ms(1个周期)停1秒(2个周期)
else if(currentMode == MODE_3) {
if(stepCount < 8) { // 总共8个步骤（4次转停）
if(stepCount % 2 == 0) { // 奇数步骤：转500ms
motorForward();
} else { // 偶数步骤：停1秒
motorStop();
}
stepCount++;
} else {
stepCount = 0;
timerCount = 0;
// 切换到下一个模式
if(modeDirection) {
currentMode = (currentMode + 1) % MODE_COUNT;
} else {
currentMode = (currentMode == 0) ? MODE_COUNT - 1 : currentMode - 1;
}
}
}
if((_usr_module_cfg.local_moto_mode>0)&&(_usr_module_cfg.local_moto_mode<3))usr_var.usr_auto_off_cnt++;
if(usr_var.usr_auto_off_cnt>=1200)
{
usr_var.usr_auto_off_cnt=0;
usr_var.usr_allow_to_sleep_cnt=6;
_usr_module_cfg.local_moto_mode=0;
//_usr_module_cfg.power_on_flag=0;
//sys_timeout_add(NULL,usr_le_120_notify_data,100);
sys_timeout_add(NULL,usr_write_device_sta,600);
}
}
void usr_clear_up()
{
timerCount = 0;
stepCount = 0;
}
void usr_clear_moto()
{
_usr_module_cfg.local_moto_mode=0;
_usr_module_cfg.usr_dizhuo_mode=0;
_usr_module_cfg.usr_douban_mode=0;
_usr_module_cfg.usr_doumaoshoudong=0;
}
u8 usr_get_work_status()
{
if((_usr_module_cfg.local_moto_mode==0)&&\
(_usr_module_cfg.usr_dizhuo_mode==0)&&\
(_usr_module_cfg.usr_douban_mode==0)&&\
(_usr_module_cfg.usr_doumaoshoudong==0))
{
return 0;
}
return 1;
}
u8 usr_allow_to_sleep()
{
if((usr_get_work_status()==0)&&(usr_var.usr_power_charge_flag==2))
{
if(usr_var.usr_goto_pair==0)
{
if((_usr_module_cfg.local_moto_mode==0)||(_usr_module_cfg.local_moto_mode==3))
{
return 1;
}
else
{
return 0;
}
}
else
{
return 0;
}
}
return 0;
}
static u8 usr_work_idle_query(void)
{
if(usr_var.usr_allow_to_sleep_cnt)return 0;
if((_usr_module_cfg.power_on_flag==0)&&(usr_var.usr_power_charge_flag==2))
{
return 1;
}
if(usr_allow_to_sleep())
{
return 1;
}
else
{
return 0;
}
}
REGISTER_LP_TARGET(usr_work_lp_target) = {
.name = "usr_work_lp",
.is_idle = usr_work_idle_query,
};
void usr_printf_sta()
{
//printf("local_moto %d usr_dizhuo %d usr_douban %d usr_shoudong%d charge_flag %d usr_var.usr_goto_pair %d\n",_usr_module_cfg.local_moto_mode,_usr_module_cfg.usr_dizhuo_mode,_usr_module_cfg.usr_douban_mode,_usr_module_cfg.usr_doumaoshoudong,usr_var.usr_power_charge_flag,usr_var.usr_goto_pair);
}
void usr_moto_main()
{
static u8 down_cycle_cnt=0;
static u8 up_cycle_cnt=0;
static u8 up_dir=1;
//printf("usr_moto_main\n");
usr_printf_sta();
if(usr_var.usr_allow_to_sleep_cnt)usr_var.usr_allow_to_sleep_cnt--;
if(usr_var.usr_power_charge_flag==1)
{
//_usr_module_cfg.local_moto_mode=3;
usr_set_up_moto(0,DIR_F);
usr_set_down_moto(0,DIR_F);
return;
}
if(_usr_module_cfg.power_on_flag==0)
{
usr_var.usr_auto_off_cnt=0;
usr_set_up_moto(0,DIR_F);
usr_set_down_moto(0,DIR_F);
return;
}
if(usr_var.usr_goto_pair)
{
_usr_module_cfg.local_moto_mode=0x03;
usr_var.usr_auto_off_cnt=0;
usr_set_up_moto(0,DIR_F);
usr_set_down_moto(0,DIR_F);
return;
}
switch(_usr_module_cfg.local_moto_mode)
{
case 0x00:///关闭
if(_usr_module_cfg.power_on_flag==0)
{
usr_var.usr_auto_off_cnt=0;
usr_set_up_moto(0,DIR_F);
usr_set_down_moto(0,DIR_F);
}
else
{
switch(_usr_module_cfg.usr_dizhuo_mode)///0：关闭；1：平稳；2：狂转
{
case 0x01:///平稳
usr_pwm_reinit();
if(down_cycle_cnt<=3)
{
usr_set_down_moto(1,LOW_DUTY-10);
}
else if(down_cycle_cnt==4)
{
usr_set_down_moto(0,OFF_DUTY);
}
else
{
usr_set_down_moto(2,LOW_DUTY-10);
}
down_cycle_cnt++;
if(down_cycle_cnt>8)
{
down_cycle_cnt=0;
usr_set_down_moto(0,DIR_F);
}
break;
case 0x02:///狂转
usr_pwm_reinit();
if(down_cycle_cnt<=5)
{
usr_set_down_moto(1,HIG_DUTY);
}
else if(down_cycle_cnt==6)
{
usr_set_down_moto(0,OFF_DUTY);
}
else
{
usr_set_down_moto(2,HIG_DUTY);
}
down_cycle_cnt++;
// printf("down_cycle_cnt = %d\n",down_cycle_cnt);
if(down_cycle_cnt>12)
{
down_cycle_cnt=0;
usr_set_down_moto(0,DIR_F);
}
break;
default:
usr_set_down_moto(0,OFF_DUTY);
break;
}
if(_usr_module_cfg.usr_douban_mode==0)
{
if(_usr_module_cfg.usr_doumaoshoudong==0)
{
usr_set_up_moto(0,DIR_F);
}
else
{
usr_pwm_reinit();
usr_set_up_moto(_usr_module_cfg.usr_doumaoshoudong,LOW_DUTY+10);
up_cycle_cnt++;
if(up_cycle_cnt>=3)
{
_usr_module_cfg.usr_doumaoshoudong=0;
up_cycle_cnt=0;
}
}
}
else
{
//up_cycle_cnt=0;
switch(_usr_module_cfg.usr_douban_mode)//逗猫棒摇动模式 | 0：关闭；1：自动; 2：转圈; 3:抖动;
{
case 0x01:
usr_pwm_reinit();
up_cycle_cnt=0;
usr_up_moto_mode2();
// putchar('1');
break;
case 0x02:
usr_pwm_reinit();
usr_clear_up();
if(up_cycle_cnt<=10)
{
usr_set_up_moto(1,LOW_DUTY+20);
}
else if(up_cycle_cnt==11)
{
usr_set_up_moto(0,0);
}
else
{
usr_set_up_moto(2,LOW_DUTY+20);
}
up_cycle_cnt++;
if(up_cycle_cnt>22)
{
usr_set_up_moto(0,0);
up_cycle_cnt=0;
}
//printf("up_cycle_cnt = %d\n",up_cycle_cnt);
break;
case 0x03:
usr_pwm_reinit();
usr_clear_up();
up_cycle_cnt++;
if(up_dir==0)up_dir=1;
if((up_cycle_cnt%2)==0)
{
usr_set_up_moto(0,0);
}
else
{
usr_set_up_moto(up_dir,LOW_DUTY+10);
}
if(up_cycle_cnt>20)
{
up_cycle_cnt=0;
if(up_dir==1)up_dir=2;
else up_dir=1;
}
//putchar('3');
break;
default:
//putchar('4');
break;
}
}
}
break;
case 0x01:///打鸡血
up_cycle_cnt=0;
usr_pwm_reinit();
usr_up_moto_mode();
if(down_cycle_cnt<=5)
{
usr_set_down_moto(1,HIG_DUTY);
}
else if(down_cycle_cnt==6)
{
usr_set_down_moto(0,DIR_F);
}
else
{
usr_set_down_moto(2,HIG_DUTY);
}
down_cycle_cnt++;
// printf("down_cycle_cnt = %d\n",down_cycle_cnt);
if(down_cycle_cnt>12)
{
down_cycle_cnt=0;
usr_set_down_moto(0,DIR_F);
}
break;
case 0x02:///佛系
up_cycle_cnt=0;
usr_pwm_reinit();
usr_up_moto_mode();
if(down_cycle_cnt<=3)
{
usr_set_down_moto(1,LOW_DUTY-10);
}
else if(down_cycle_cnt==4)
{
usr_set_down_moto(0,DIR_F);
}
else
{
usr_set_down_moto(2,LOW_DUTY-10);
}
down_cycle_cnt++;
if(down_cycle_cnt>8)
{
down_cycle_cnt=0;
usr_set_down_moto(0,DIR_F);
}
break;
case 0x03:///配对中
up_cycle_cnt=0;
down_cycle_cnt=0;
usr_var.usr_auto_off_cnt=0;
usr_set_up_moto(0,DIR_F);
usr_set_down_moto(0,DIR_F);
break;
}
//printf("down_cycle_cnt = %d local_moto_mode = %d\n ",down_cycle_cnt,local_moto_mode);
}
apps/usr_rtc/alarm.h
-103
View File
@@ -1,103 +0,0 @@
#ifndef __ALARM_H__
#define __ALARM_H__
//#define RTC_ALM_EN 1
#include "typedef.h"
#include "system/includes.h"
#pragma pack(1)
typedef struct _RTC_TIME {
u16 dYear; ///<年份
u8 bMonth; ///<月份
u8 bDay; ///<天数
u8 bHour; ///<时
u8 bMin; ///<分
u8 bSec; ///<秒
// u8 bWeekday; ///<星期几
} RTC_TIME;
#pragma pack()
typedef struct __ALARM__ {
u8 index;
u8 sw;
u8 mode;
struct sys_time time;
u8 name_len;
} T_ALARM, *PT_ALARM;
typedef struct __alarm_vm__ {
u16 head;
T_ALARM alarm;
} T_ALARM_VM, *PT_ALARM_VM;
enum {
E_ALARM_WRITE_VM_ERR = 0x00,
E_ALARM_WRITE_VM_SUCC,
};
enum {
E_ALARM_MODE_ONCE = 0x00,
E_ALARM_MODE_EVERY_DAY = 0x01,
E_ALARM_MODE_EVERY_MONDAY = 0x02,
E_ALARM_MODE_EVERY_TUESDAY = 0x04,
E_ALARM_MODE_EVERY_WEDNESDAY = 0x08,
E_ALARM_MODE_EVERY_THURSDAY = 0x10,
E_ALARM_MODE_EVERY_FRIDAY = 0x20,
E_ALARM_MODE_EVERY_SATURDAY = 0x40,
E_ALARM_MODE_EVERY_SUNDAY = 0x80,
};
enum {
E_WEEK_MONDAY = 0x01,
E_WEEK_TUESDAY,
E_WEEK_WEDNESDAY,
E_WEEK_THURSDAY,
E_WEEK_FRIDAY,
E_WEEK_SATURDAY,
E_WEEK_SUNDAY,
};
typedef enum {
TIME_MEMBER_YEAR = 0x0,
TIME_MEMBER_MONTH,
TIME_MEMBER_DAY,
TIME_MEMBER_HOUR,
TIME_MEMBER_MIN,
TIME_MEMBER_SEC,
TIME_MEMBER_MAX,
} TIME_MEMBER_ENUM;
enum {
E_SUCCESS = 0x00,
E_FAILURE,
};
/* macro */
#define M_MAX_ALARM_NUMS 5
#define M_MAX_ALARM_NAME_LEN 32
#define M_MAX_ALARM_INDEX (M_MAX_ALARM_NUMS-1)
#define M_MAX_ALARM_MODE (0xFE)
void alarm_init();
u8 alarm_get_info(PT_ALARM p, u8 index);
void rtc_update_time_api(struct sys_time *time);
void alarm_ring_start();
void alarm_active_flag_set(u8 flag);
u8 alarm_active_flag_get(void);
u8 rtc_calculate_week_val(struct sys_time *data_time);
void rtc_calculate_next_few_day(struct sys_time *data_time, u8 days); //未来几天的日期
u16 month_for_day(u8 month, u16 year);
void *is_sys_time_online();
void alarm_update_info_after_isr(void);
void alarm_event_handler(struct sys_event *event, void *priv);
u8 alarm_add(PT_ALARM p, u8 index);
#endif //end of __ALARM_H__
apps/usr_rtc/alarm_api.c
-961
View File
@@ -1,961 +0,0 @@
#include "system/includes.h"
#include "system/timer.h"
#include "app_main.h"
#include "tone_player.h"
#include "app_task.h"
#include "alarm.h"
#include "app_config.h"
#if TCFG_APP_RTC_EN
#ifdef RTC_ALM_EN
/* #define ALARM_DEBUG_EN */
#ifdef ALARM_DEBUG_EN
#define alarm_printf printf
#define alarm_putchar putchar
#define alarm_printf_buf put_buf
#else
#define alarm_printf(...)
#define alarm_putchar(...)
#define alarm_printf_buf(...)
#endif
#define PRINT_FUN() alarm_printf("func : %s\n", __FUNCTION__)
#define PRINT_FUN_RETURN_INFO() alarm_printf("func : %s, line : %d.\n", __FUNCTION__, __LINE__)
/*************************************************************
此文件函数主要是rtc闹钟的实现代码
用户可以不主要关心实现，专心留意api调用
常用的api 有:
u8 alarm_add(PT_ALARM p, u8 index);
增加闹钟
void alarm_delete(u8 index);
删除闹钟
void rtc_update_time_api(struct sys_time *time)
更新时间api(更新了时间必须调用该接口)
u8 alarm_active_flag_get(void);
闹钟到达的标志
u8 alarm_get_info(PT_ALARM p, u8 index)
获取闹钟信息
u8 alarm_get_active_index(void);
获取当前激活使能的闹钟(可以理解为下一个会响的闹钟)
u8 alarm_get_total(void)
获取当前已经设备的闹钟数(包括关闭的闹钟)
void rtc_calculate_next_few_day(struct sys_time *data_time,u8 days)
获取今天星期几
void alarm_name_set(u8 *p, u8 index, u8 len)
设置闹钟名字
u8 alarm_name_get(u8 *p, u8 index)
获取闹钟名字
**************************************************************/
static volatile u8 g_alarm_active_flag = 0;
static volatile u8 alarm_cur_active = 0;//当前在响的闹钟
typedef struct __alarm_map__ {
u32 mask: 16;
u32 map :
((M_MAX_ALARM_NUMS + 7) / 8 * 8); //存储了闹钟数目信息（闹钟数）
u32 map_sw :
((M_MAX_ALARM_NUMS + 7) / 8 * 8); //存储闹钟的使能开关(闹钟开关)
u32 active_map :
((M_MAX_ALARM_NUMS + 7) / 8 * 8); //存储最后激活闹钟
} T_ALARM_MAP, *PT_ALARM_MAP;
/* volatile u8 g_alarm_ring_max_cnt = 100; */
static T_ALARM alarm_tab[M_MAX_ALARM_NUMS] = {0};
static u8 alarm_name[M_MAX_ALARM_NAME_LEN] = {0};
#define RTC_MASK (0x55aa+M_MAX_ALARM_NAME_LEN)
static void *dev_handle;
T_ALARM_MAP alarm_map = {0};
/*----------------------------------------------------------------------------*/
/* debug 函数代码 */
/*----------------------------------------------------------------------------*/
void alarm_vm_puts_info(PT_ALARM p)
{
alarm_printf("index : %d\n", p->index);
alarm_printf("mode: %d\n", p->mode);
alarm_printf("sw: %d\n", p->sw);
/* alarm_puts_time(&(p->time)); */
}
void alarm_puts_time(struct sys_time *pTime)
{
u8 week = 0;
#if 1
alarm_printf("alarm_time : %d-%d-%d,%d:%d:%d\n", pTime->year, pTime->month, pTime->day, pTime->hour, pTime->min, pTime->sec);
week = rtc_calculate_week_val(pTime);
#endif
alarm_printf("alarm week : %d\n", week);
}
/*----------------------------------------------------------------------------*/
/* rtc 硬化相关代码*/
/*----------------------------------------------------------------------------*/
void *is_sys_time_online()
{
return dev_handle;
}
static void get_sys_time(struct sys_time *time)//获取时间
{
if (!dev_handle) {
return ;
}
dev_ioctl(dev_handle, IOCTL_GET_SYS_TIME, (u32)time);
}
static void set_sys_time(struct sys_time *time)//设置时间
{
if (!dev_handle) {
return ;
}
dev_ioctl(dev_handle, IOCTL_SET_SYS_TIME, (u32)time);
}
void alarm_hw_set_sw(u8 sw)//闹钟开关
{
/* printf("alarm sw : %d\n", sw); */
if (!dev_handle) {
return ;
}
dev_ioctl(dev_handle, IOCTL_SET_ALARM_ENABLE, !!sw);
}
void alarm_hw_write_time(struct sys_time *time, u8 sw)//写闹钟寄存器
{
if (!dev_handle) {
return ;
}
alarm_printf("alarm_time : %d-%d-%d,%d:%d:%d\n", time->year, time->month, time->day, time->hour, time->min, time->sec);
alarm_hw_set_sw(0);
dev_ioctl(dev_handle, IOCTL_SET_ALARM, (u32)time);
alarm_hw_set_sw(sw);
}
/*----------------------------------------------------------------------------*/
/* vm读写操作部分代码 */
/*----------------------------------------------------------------------------*/
static void alarm_vm_reset()
{
int i = 0;
int ret = 0;
T_ALARM_MAP map_temp = {0};
memset(&map_temp, 0x0, sizeof(T_ALARM_MAP));
map_temp.mask = RTC_MASK;
ret = syscfg_write(VM_ALARM_MASK, (u8 *)&map_temp, sizeof(T_ALARM_MAP));
if (ret != sizeof(T_ALARM_MAP)) {
PRINT_FUN_RETURN_INFO();
return;
}
for (i = 0; i < M_MAX_ALARM_NUMS; i++) {
T_ALARM_VM tmp = {0};
tmp.head = RTC_MASK;
tmp.alarm.index = i;
ret = syscfg_write(VM_ALARM_0 + i, &tmp, sizeof(T_ALARM_VM));
if (ret != sizeof(T_ALARM_VM)) {
alarm_printf("The %d alarm write vm err!\n", index);
return;
}
}
}
//写闹钟map表
static void alarm_vm_write_mask(PT_ALARM_MAP map)
{
int ret = 0;
PRINT_FUN();
T_ALARM_MAP map_temp = {0};
memcpy(&map_temp, map, sizeof(T_ALARM_MAP));
if (map_temp.mask != RTC_MASK) {
memset(&map_temp, 0x0, sizeof(T_ALARM_MAP));
map_temp.mask = RTC_MASK;
}
ret = syscfg_write(VM_ALARM_MASK, (u8 *)&map_temp, sizeof(T_ALARM_MAP));
if (ret != sizeof(T_ALARM_MAP)) {
PRINT_FUN_RETURN_INFO();
return;
}
}
//获取闹钟所有信息
static void alarm_vm_read_info(PT_ALARM_MAP map)
{
PRINT_FUN();
T_ALARM_VM tmp;
int ret = 0;
u8 i;
ret = syscfg_read(VM_ALARM_MASK, (u8 *)map, sizeof(T_ALARM_MAP));
if (ret != sizeof(T_ALARM_MAP) || map->mask != RTC_MASK) {
PRINT_FUN_RETURN_INFO();
memset(map, 0, sizeof(T_ALARM_MAP));
map->mask = RTC_MASK;
alarm_vm_reset();
return;
}
for (i = 0; i < M_MAX_ALARM_NUMS; i++) {
if ((map->map) & BIT(i)) {
ret = syscfg_read(VM_ALARM_0 + i, &tmp, sizeof(T_ALARM_VM));
if (ret != sizeof(T_ALARM_VM) || tmp.head != RTC_MASK) {
alarm_printf("can't find the %d alarm from vm.\n", i);
memset(&(alarm_tab[i]), 0x00, sizeof(T_ALARM));
continue;
}
printf("vm info : index=%d, sw=%d, mode=%d, h=%d, m=%d, name_len=%d\n", tmp.alarm.index, tmp.alarm.sw, tmp.alarm.mode, \
tmp.alarm.time.hour, tmp.alarm.time.min, tmp.alarm.name_len);
memcpy(&alarm_tab[i], &(tmp.alarm), sizeof(T_ALARM));
if (alarm_tab[i].sw) {
map->map_sw |= BIT(i);
} else {
map->map_sw &= ~(BIT(i));
}
}
}
}
//更新闹钟信息
static void alarm_vm_write_info_by_index(PT_ALARM_MAP map, u8 index)
{
PRINT_FUN();
s32 ret = 0;
T_ALARM_VM tmp;
tmp.head = RTC_MASK;
memcpy(&(tmp.alarm), &alarm_tab[index], sizeof(T_ALARM));
tmp.alarm.index = index;
ret = syscfg_write(VM_ALARM_0 + index, &tmp, sizeof(T_ALARM_VM));
if (ret != sizeof(T_ALARM_VM)) {
alarm_printf("The %d alarm write vm err!\n", index);
return;
}
alarm_printf("vm info : index=%d, sw=%d, mode=%d, h=%d, m=%d, name_len=%d\n", tmp.alarm.index, tmp.alarm.sw, tmp.alarm.mode, \
tmp.alarm.time.hour, tmp.alarm.time.min, tmp.alarm.name_len);
alarm_vm_write_mask(map);
return;
}
/*----------------------------------------------------------------------------*/
/*闹钟名字部分代码 */
/*----------------------------------------------------------------------------*/
static void alarm_vm_write_name(u8 *p, u8 index)
{
PRINT_FUN();
s32 ret = 0;
ret = syscfg_write(VM_ALARM_NAME_0 + index, p, sizeof(alarm_name));
if (ret < 0) {
PRINT_FUN_RETURN_INFO();
return;
}
return;
}
static void alarm_vm_read_name(u8 *p, u8 index)
{
PRINT_FUN();
s32 ret = 0;
ret = syscfg_read(VM_ALARM_NAME_0 + index, p, sizeof(alarm_name));
if (ret < 0) {
PRINT_FUN_RETURN_INFO();
return;
}
return;
}
void alarm_name_clear(void)
{
PRINT_FUN();
memset(alarm_name, 0x00, sizeof(alarm_name));
return;
}
void alarm_name_set(u8 *p, u8 index, u8 len)
{
PRINT_FUN();
if (index > M_MAX_ALARM_INDEX) {
PRINT_FUN_RETURN_INFO();
alarm_printf("alarm is full!\n");
return;
}
if ((len == 0) || (len > sizeof(alarm_name))) {
PRINT_FUN_RETURN_INFO();
return;
}
alarm_name_clear();
alarm_printf("alarm name len : %d\n", len);
alarm_printf_buf(p, len);
memcpy(alarm_name, p, len);
alarm_vm_write_name(alarm_name, index);
return;
}
u8 alarm_name_get(u8 *p, u8 index)
{
PRINT_FUN();
u8 name_len = 0;
if (index > M_MAX_ALARM_INDEX) {
PRINT_FUN_RETURN_INFO();
return 0;
}
alarm_vm_read_name(alarm_name, index);
name_len = alarm_tab[index].name_len;
memcpy(p, alarm_name, name_len);
alarm_printf("alarm name len : %d\n", name_len);
alarm_printf_buf(alarm_name, name_len);
return name_len;
}
/*----------------------------------------------------------------------------*/
/*工具函数部分代码 */
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
/**@brief 月份换算为月天数
@param month，year
@return 月份天数
@note
*/
/*----------------------------------------------------------------------------*/
u16 month_for_day(u8 month, u16 year)
{
extern u16 month_to_day(u16 year, u8 month);
return month_to_day(year, month);
}
/*----------------------------------------------------------------------------*/
/**@brief 计算未来几天的日期 days要小于29,防止跨两个月
@param data_time--计算日期
@return none
@note
*/
/*----------------------------------------------------------------------------*/
void rtc_calculate_next_few_day(struct sys_time *data_time, u8 days)
{
if (!days || days >= 29) {
return;
}
u16 tmp16 = month_for_day(data_time->month, data_time->year);
data_time->day += days;
if (data_time->day > tmp16) {
data_time->month++;
data_time->day -= tmp16;
if (data_time->month > 12) {
data_time->month = 1;
data_time->year++;
}
}
}
/*----------------------------------------------------------------------------*/
/**@brief 日期转换为星期
@param data_time--日期
@return 星期
@note
*/
/*----------------------------------------------------------------------------*/
//蔡勒（Zeller）公式：w=y+[y/4]+[c/4]-2c+[26x(m+1)/10]+d-1
u8 rtc_calculate_week_val(struct sys_time *data_time)
{
struct sys_time t_time;
u32 century, val, year;
memcpy(&t_time, data_time, sizeof(struct sys_time));
if (t_time.month < 3) {
t_time.month = t_time.month + 12;
t_time.year--;
}
year = t_time.year % 100;
century = t_time.year / 100;
val = year + (year / 4) + (century / 4) + (26 * (t_time.month + 1) / 10) + t_time.day;
val = val - century * 2 - 1;
return (u8)(val % 7);
}
static int __alarm_cmp_time_num(u32 num1, u32 num2)
{
int ret = -2;
if (num1 > num2) {
ret = 1;
} else if (num1 == num2) {
ret = 0;
} else if (num1 < num2) {
ret = -1;
}
return ret;
}
/*
* 函数功能 ：比较两个闹钟的时间
* 函数形参 ：time1 - 闹钟1；time2 - 闹钟2
* 返回值 ：0-两闹钟相等；1-闹钟1时间比对比闹钟2要晚；-1-闹钟1比对比闹钟2早 -2-比较出错
* 备注 ：无
*
* */
static int alarm_cmp_time_member(struct sys_time *time1, struct sys_time *time2, TIME_MEMBER_ENUM type)
{
switch (type) {
case TIME_MEMBER_YEAR:
return __alarm_cmp_time_num(time1->year, time2->year);
case TIME_MEMBER_MONTH:
return __alarm_cmp_time_num(time1->month, time2->month);
case TIME_MEMBER_DAY:
return __alarm_cmp_time_num(time1->day, time2->day);
case TIME_MEMBER_HOUR:
return __alarm_cmp_time_num(time1->hour, time2->hour);
case TIME_MEMBER_MIN:
return __alarm_cmp_time_num(time1->min, time2->min);
case TIME_MEMBER_SEC:
return __alarm_cmp_time_num(time1->sec, time2->sec);
default:
return -2;
}
return -2;
}
/*
* 函数功能 ：比较两个闹钟的时间
* 函数形参 ：time1 - 闹钟1；time2 - 闹钟2
* 返回值 ：0-两闹钟相等；1-闹钟1时间比对比闹钟2要晚；-1-闹钟1比对比闹钟2早 -2-比较出错
* 备注 ：无
*
* */
static int alarm_cmp_time(struct sys_time *time1, struct sys_time *time2)
{
u8 i;
int ret = 0;
for (i = 0; i < TIME_MEMBER_MAX; i++) {
ret = alarm_cmp_time_member(time1, time2, i);
if (ret != 0) {
break;
}
}
return ret;
}
/*----------------------------------------------------------------------------*/
/*核心部分代码 */
/*----------------------------------------------------------------------------*/
/*
** 函数功能 ：根据闹钟的模式计算出实际时间
** 函数形参 ：pTime-闹钟时间结构体；week-当下星期； mode-闹钟模式
** 返回值 ：void
** 备注 ：无
*/
static void __alarm_calc_time_by_week_mode(struct sys_time *pTime, u8 mode)
{
PRINT_FUN();
u8 i = 0;
u8 alarm_week = 0;
u8 tmp_mode = 0;
alarm_week = rtc_calculate_week_val(pTime);//alarm_week 可以理解为最近可以设置的闹钟（忽略week）
if (alarm_week == 0) {
alarm_week = 7; //星期天写成7，方便对比计算
}
//查找当前可以设置闹钟日期最近的日期
for (i = 1; i < 8; i++) {
if (mode & BIT(i)) {
if (i >= alarm_week) {
tmp_mode = i;
break;
}
}
}
if (i >= 8) {//翻越了星期的
for (i = 1; i < 8; i++) {
if (mode & BIT(i)) {
tmp_mode = i;
break;
}
}
}
if ((tmp_mode >= 1) && (tmp_mode < 8)) {
if (tmp_mode > alarm_week) {
alarm_printf("***a***\n");
//没有翻越星期
rtc_calculate_next_few_day(pTime, tmp_mode - alarm_week);
} else if (tmp_mode < alarm_week) {
//翻越了星期
alarm_printf("***b***\n");
rtc_calculate_next_few_day(pTime, 7 - (alarm_week - tmp_mode));
}
}
return;
}
/*
** 函数功能 ：根据闹钟的时、分计算出它具体的时间（年、月、日、时、分、秒）
** 函数形参 ：带有时、分和闹钟模式的时间结构体
** 返回值 ：void
** 备注 ：无
*/
static void alarm_calc_real_time_by_index(struct sys_time *cTime, u8 index)
{
struct sys_time tmp = {0};
PT_ALARM pAlarm_tab;
if (index > M_MAX_ALARM_INDEX) {
PRINT_FUN_RETURN_INFO();
return;
}
pAlarm_tab = &(alarm_tab[index]);
struct sys_time *pTime = &(pAlarm_tab->time);
if (pAlarm_tab->mode > M_MAX_ALARM_MODE) {
PRINT_FUN_RETURN_INFO();
return;
}
u32 c_tmp = ((cTime->hour & 0x1f) << 12) | ((cTime->min & 0x3f) << 6) | (cTime->sec & 0x3f);
u32 p_tmp = ((pTime->hour & 0x1f) << 12) | ((pTime->min & 0x3f) << 6) | (pTime->sec & 0x3f);
if (p_tmp > c_tmp) { //时间未到
PRINT_FUN_RETURN_INFO();
pTime->year = cTime->year;
pTime->month = cTime->month;
pTime->day = cTime->day;
pTime->sec = 0;
} else {
PRINT_FUN_RETURN_INFO();
memcpy(&tmp, cTime, sizeof(struct sys_time));
rtc_calculate_next_few_day(&tmp, 1);
pTime->year = tmp.year;
pTime->month = tmp.month;
pTime->day = tmp.day;
pTime->sec = 0;
}
if ((pAlarm_tab->mode != E_ALARM_MODE_ONCE) && (pAlarm_tab->mode != E_ALARM_MODE_EVERY_DAY)) {
__alarm_calc_time_by_week_mode(pTime, pAlarm_tab->mode);
}
alarm_puts_time(pTime);
}
static void __alarm_get_the_earliest(void)
{
PRINT_FUN();
int ret = 0;
u8 index = 0;
u8 i = 0;
struct sys_time *pTmp = NULL;
alarm_map.active_map = 0 ;
for (i = 0; i < M_MAX_ALARM_NUMS; i++) {
if (alarm_map.map_sw & BIT(i)) {
alarm_map.active_map |= BIT(i) ;
pTmp = &(alarm_tab[i].time);
index = i;
break;
}
}
if (i >= M_MAX_ALARM_NUMS) {
alarm_printf("***no alarm***\n");
alarm_hw_set_sw(0);
return;
}
for (i = index + 1; i < M_MAX_ALARM_NUMS; i++) {
if (alarm_map.map_sw & BIT(i)) {
ret = alarm_cmp_time(pTmp, &(alarm_tab[i].time));
if (0 == ret) {
alarm_map.active_map |= BIT(i);
alarm_printf("***A***\n");
} else if (1 == ret) {
alarm_printf("***B***\n");
pTmp = &(alarm_tab[i].time);
index = i;
alarm_map.active_map = 0;
alarm_map.active_map |= BIT(i);
}
}
}
/* alarm_puts_time(pTmp); */
/* printf("find the %dth alarm, the save alarm : %x\n", index, alarm_map.active_map); */
alarm_hw_write_time(pTmp, alarm_tab[index].sw);
return;
}
static void __alarm_update_all_time(struct sys_time *cTIME)
{
PRINT_FUN();
u8 i = 0;
for (i = 0; i < M_MAX_ALARM_NUMS; i++) {
if (alarm_map.map_sw & BIT(i)) {
alarm_calc_real_time_by_index(cTIME, i);
}
}
return;
}
static void alarm_update()
{
PRINT_FUN();
struct sys_time current_time = {0};
if (!is_sys_time_online()) {
return ;
}
get_sys_time(&current_time);
local_irq_disable();
__alarm_update_all_time(&current_time);
local_irq_enable();
__alarm_get_the_earliest();
}
u8 alarm_get_active_index(void)
{
return alarm_cur_active;
}
u8 alarm_get_info(PT_ALARM p, u8 index)
{
u8 ret = E_SUCCESS;
local_irq_disable();
if (alarm_map.map & BIT(index)) {
p->index = alarm_tab[index].index;
p->sw = alarm_tab[index].sw;
p->mode = alarm_tab[index].mode;
p->time.hour = alarm_tab[index].time.hour;
p->time.min = alarm_tab[index].time.min;
p->name_len = alarm_tab[index].name_len;
} else {
memset(p, 0x0, sizeof(T_ALARM));
ret = E_FAILURE;
}
local_irq_enable();
return ret;
}
u8 alarm_get_total(void)
{
PRINT_FUN();
u8 total = 0;
u8 i = 0;
local_irq_disable();
for (i = 0; i < M_MAX_ALARM_NUMS; i++) {
if (alarm_map.map & BIT(i)) {
total++;
}
}
local_irq_enable();
alarm_printf("total %d alarm\n", total);
return total;
}
void rtc_update_time_api(struct sys_time *time)
{
if (!is_sys_time_online()) {
return ;
}
set_sys_time(time);
local_irq_disable();
__alarm_update_all_time(time);
local_irq_enable();
__alarm_get_the_earliest();
alarm_vm_write_mask(&alarm_map);
}
void alarm_update_info_after_isr(void)
{
PRINT_FUN();
struct sys_time time = {0};
if (!is_sys_time_online()) {
return ;
}
get_sys_time(&time);
u8 i = 0;
printf("alarm_map.active_map =%x\n", alarm_map.active_map);
local_irq_disable();
alarm_cur_active = alarm_map.active_map;
for (i = 0; i < M_MAX_ALARM_NUMS; i++) {
if (alarm_map.active_map & BIT(i)) {
if (alarm_tab[i].mode != 0) {
//闹钟不只响一次
//计算一次闹钟的时间
alarm_calc_real_time_by_index(&time, i);
} else {
//闹钟只响一次
alarm_map.map_sw &= ~BIT(i);
alarm_tab[i].sw = 0;
local_irq_enable();
alarm_vm_write_info_by_index(&alarm_map, i);
local_irq_disable();
}
}
}
local_irq_enable();
__alarm_get_the_earliest();
alarm_vm_write_mask(&alarm_map);
}
u8 alarm_add(PT_ALARM p, u8 index)
{
struct sys_time current_time = {0};
PRINT_FUN();
u8 ret = E_SUCCESS;
if (!is_sys_time_online()) {
return E_FAILURE;
}
if (index > M_MAX_ALARM_INDEX) {
PRINT_FUN_RETURN_INFO();
alarm_printf("alarm is full!\n");
return E_FAILURE;
}
if (p->mode > M_MAX_ALARM_MODE) {
PRINT_FUN_RETURN_INFO();
alarm_printf("alarm's mode is error");
return E_FAILURE;
}
local_irq_disable();
alarm_map.map |= BIT(index);
if (0 == p->sw) {
alarm_printf("close the %dth alarm!\n", p->index);
alarm_map.map_sw &= ~BIT(p->index);
} else if (1 == p->sw) {
alarm_printf("set the %dth alarm!\n", p->index);
alarm_map.map_sw |= BIT(p->index);
}
alarm_tab[index].index = p->index;
alarm_tab[index].sw = p->sw;
alarm_tab[index].mode = p->mode;
alarm_tab[index].time.hour = p->time.hour;
alarm_tab[index].time.min = p->time.min;
alarm_tab[index].name_len = p->name_len;
get_sys_time(&current_time);
alarm_calc_real_time_by_index(&current_time, index);//根据当前时间和闹钟模式计算出最新闹钟时间
local_irq_enable();
__alarm_get_the_earliest();
alarm_vm_write_info_by_index(&alarm_map, index);
return ret;
}
void alarm_delete(u8 index)
{
PRINT_FUN();
if (index > M_MAX_ALARM_INDEX) {
PRINT_FUN_RETURN_INFO();
alarm_printf("alarm is full!\n");
return;
}
alarm_printf("delete the %dth alarm!\n", index);
local_irq_disable();
alarm_map.map &= ~BIT(index);
alarm_map.map_sw &= ~BIT(index);
alarm_tab[index].sw = 0;
local_irq_enable();
__alarm_get_the_earliest();
alarm_vm_write_info_by_index(&alarm_map, index);
return;
}
void alarm_active_flag_set(u8 flag)
{
g_alarm_active_flag = flag;
return;
}
u8 alarm_active_flag_get(void)
{
return g_alarm_active_flag;
}
static void alarm_check(void *priv)
{
extern APP_VAR app_var;
extern u32 timer_get_ms(void);
if ((timer_get_ms() - app_var.start_time) > 3000) {
struct sys_event e;
e.type = SYS_DEVICE_EVENT;
e.arg = (void *)DEVICE_EVENT_FROM_ALM;
e.u.dev.event = DEVICE_EVENT_IN;
e.u.dev.value = 0;
sys_event_notify(&e);
} else {
sys_timeout_add(NULL, alarm_check, 100);
}
}
void user_check_default_time()
{
struct sys_time current_time;
get_sys_time(&current_time);
if(current_time.year < 2025 || current_time.year > 2098){
printf("current_time.year111 == %d\n",current_time.year);
set_rtc_default_time(&current_time);
rtc_update_time_api(&current_time);
}
else if(current_time.month < 1 || current_time.month > 12){
printf("current_time.year222 == %d\n",current_time.year);
set_rtc_default_time(&current_time);
rtc_update_time_api(&current_time);
}
else if(current_time.day < 1 || current_time.day > 31){
printf("current_time.year333 == %d\n",current_time.year);
set_rtc_default_time(&current_time);
rtc_update_time_api(&current_time);
}
else if(current_time.hour < 0 || current_time.hour > 23){
printf("current_time.year444 == %d\n",current_time.year);
set_rtc_default_time(&current_time);
rtc_update_time_api(&current_time);
}
else if(current_time.min < 0 || current_time.min > 59){
printf("current_time.year555 == %d\n",current_time.year);
set_rtc_default_time(&current_time);
rtc_update_time_api(&current_time);
}
else if(current_time.sec < 0 || current_time.sec > 59){
printf("current_time.year666 == %d\n",current_time.year);
set_rtc_default_time(&current_time);
rtc_update_time_api(&current_time);
}
else{
}
}
void alarm_init()
{
u8 i = 0;
if (dev_handle) {
return ;
}
dev_handle = dev_open("rtc", NULL);
user_check_default_time();
if (!dev_handle) {
ASSERT(0, "%s %d \n", __func__, __LINE__);
}
alarm_vm_read_info(&alarm_map);
if (!alarm_active_flag_get()) { //判断是否闹钟在响
alarm_update();//开机重新写入闹钟寄存器信息
} else {
sys_timeout_add(NULL, alarm_check, 100);
}
/* register_sys_event_handler(SYS_ALL_EVENT, 1, NULL, alarm_event_handler); */
}
#endif //end of RTC_ALM_EN
#endif
apps/usr_rtc/alarm_user.c
-194
View File
@@ -1,194 +0,0 @@
#include "system/includes.h"
#include "alarm.h"
#include "system/timer.h"
#include "app_main.h"
#include "tone_player.h"
#include "app_task.h"
#include "btstack/avctp_user.h"
#include "app_config.h"
#if 0//TCFG_APP_RTC_EN
#define ALARM_RING_MAX 50
volatile u16 g_alarm_ring_cnt = 0;
static u16 g_alarm_dly_tmr = 0;
static u16 g_ring_playing_timer = 0;
extern u8 get_switch_to_rtc_reason();
/*************************************************************
此文件函数主要是用户主要修改的文件
void set_rtc_default_time(struct sys_time *t)
设置默认时间的函数
void alm_wakeup_isr(void)
闹钟到达的函数
void alarm_event_handler(struct sys_event *event, void *priv)
监听按键消息接口,应用于随意按键停止闹钟
int alarm_sys_event_handler(struct sys_event *event)
闹钟到达响应接口
void alarm_ring_start()
闹钟铃声播放接口
void alarm_stop(void)
闹钟铃声停止播放接口
**************************************************************/
static u8 rtc_can_run(void)
{
u8 call_status = get_call_status();
if ((call_status == BT_CALL_ACTIVE) ||
(call_status == BT_CALL_OUTGOING) ||
(call_status == BT_CALL_ALERT) ||
(call_status == BT_CALL_INCOMING)) {
//通话过程不允许开rtc
return false;
}
return true;
}
void set_rtc_default_time(struct sys_time *t)
{
t->year = 2019;
t->month = 5;
t->day = 5;
t->hour = 18;
t->min = 18;
t->sec = 18;
}
__attribute__((weak))
u8 rtc_app_alarm_ring_play(u8 alarm_state)
{
return 0;
}
void alm_wakeup_isr(void)
{
if (!is_sys_time_online()) {
alarm_active_flag_set(true);
} else {
alarm_active_flag_set(true);
struct sys_event e;
e.type = SYS_DEVICE_EVENT;
e.arg = (void *)DEVICE_EVENT_FROM_ALM;
e.u.dev.event = DEVICE_EVENT_IN;
e.u.dev.value = 0;
sys_event_notify(&e);
}
}
void alarm_ring_cnt_clear(void)
{
g_alarm_ring_cnt = 0;
}
void alarm_stop(void)
{
u32 rets_addr;
__asm__ volatile("%0 = rets ;" : "=r"(rets_addr));
printf("ALARM_STOP : 0x%x !!!\n", rets_addr);
alarm_active_flag_set(0);
alarm_ring_cnt_clear();
rtc_app_alarm_ring_play(0);
}
void alarm_play_timer_del(void)
{
if (g_ring_playing_timer) {
sys_timeout_del(g_ring_playing_timer);
g_ring_playing_timer = 0;
}
}
static void __alarm_ring_play(void *p)
{
if (g_alarm_ring_cnt > 0) {
u8 app = app_get_curr_task();
if (app != APP_RTC_TASK) {
alarm_stop();
printf("...not in rtc task\n");
return;
}
if (!tone_get_status()) {
if (!rtc_app_alarm_ring_play(1)) {
//tone_play_by_path(tone_table[IDEX_TONE_NORMAL], 0);
g_alarm_ring_cnt--;
}
}
g_ring_playing_timer = sys_timeout_add(NULL, __alarm_ring_play, 500);
} else {
if (alarm_active_flag_get()) {
// alarm_stop();
}
}
}
void alarm_ring_start()
{
if (g_alarm_ring_cnt == 0) {
g_alarm_ring_cnt = ALARM_RING_MAX;
sys_timeout_add(NULL, __alarm_ring_play, 500);
}
}
void alarm_event_handler(struct sys_event *event, void *priv)
{
}
SYS_EVENT_HANDLER(SYS_KEY_EVENT, alarm_event_handler, 2);
static void alarm_dly_play_deal(u32 event_arg)
{
u8 alm_flag = alarm_active_flag_get();
if (rtc_can_run() || (!alm_flag)) {
sys_timer_del(g_alarm_dly_tmr);
g_alarm_dly_tmr = NULL;
if (alm_flag) {
//app_task_switch_to(APP_RTC_TASK);
}
}
}
int alarm_sys_event_handler(struct sys_event *event)
{
struct application *cur;
if ((u32)event->arg == DEVICE_EVENT_FROM_ALM) {
if (event->u.dev.event == DEVICE_EVENT_IN) {
printf("alarm_sys_event_handler\n");
alarm_update_info_after_isr();
u8 app = app_get_curr_task();
if (app == APP_RTC_TASK) {
alarm_ring_start();
return false;
}
if (!rtc_can_run()) {
if (g_alarm_dly_tmr == 0) {
g_alarm_dly_tmr = sys_timer_add((event->arg), alarm_dly_play_deal, 500);
}
return false;
}
return true;
}
}
return false;
}
#endif
apps/usr_rtc/rtc.c
-118
View File
@@ -1,118 +0,0 @@
#include "app_config.h"
#include "key_event_deal.h"
#include "system/includes.h"
#include "tone_player.h"
#include "app_task.h"
#include "tone_player.h"
#include "media/includes.h"
#include "system/sys_time.h"
#include "alarm.h"
#include "clock_cfg.h"
/*************************************************************
此文件函数主要是rtc模式按键处理和事件处理
**************************************************************/
#if TCFG_APP_RTC_EN
#define LOG_TAG_CONST APP_RTC
#define LOG_TAG "[APP_RTC]"
#define LOG_ERROR_ENABLE
#define LOG_DEBUG_ENABLE
#define LOG_INFO_ENABLE
/* #define LOG_DUMP_ENABLE */
#define LOG_CLI_ENABLE
#include "debug.h"
struct rtc_opr {
void *dev_handle;
u8 rtc_set_mode;
u8 rtc_pos;
u8 alm_enable;
u8 alm_num;
struct sys_time set_time;
};
static struct rtc_opr *__this = NULL;
static u8 switch_to_rtc_reason = 0;
static void rtc_app_init()
{
if (!__this) {
__this = zalloc(sizeof(struct rtc_opr));
ASSERT(__this, "%s %di \n", __func__, __LINE__);
__this->dev_handle = dev_open("rtc", NULL);
if (!__this->dev_handle) {
ASSERT(0, "%s %d \n", __func__, __LINE__);
}
}
}
//*----------------------------------------------------------------------------*/
/**@brief rtc 退出
@param 无
@return
@note
*/
/*----------------------------------------------------------------------------*/
static void rtc_task_close()
{
if (__this) {
if (__this->dev_handle) {
dev_close(__this->dev_handle);
__this->dev_handle = NULL;
}
free(__this);
__this = NULL;
}
}
//*----------------------------------------------------------------------------*/
/**@brief rtc 启动
@param 无
@return
@note
*/
/*----------------------------------------------------------------------------*/
void rtc_task_start()
{
rtc_app_init();
}
//*----------------------------------------------------------------------------*/
/**@brief rtc 主任务
@param 无
@return 无
@note
*/
/*----------------------------------------------------------------------------*/
void app_rtc_task()
{
rtc_task_start();
}
#else
void app_rtc_task()
{
}
#endif
apps/usr_rtc/virtual_rtc.c
-358
View File
@@ -1,358 +0,0 @@
#include "app_config.h"
#include "alarm.h"
#include "app_action.h"
#include "system/includes.h"
#include "clock_cfg.h"
#include "ioctl_cmds.h"
#include "system/sys_time.h"
#if (TCFG_APP_RTC_EN && TCFG_USE_VIRTUAL_RTC)
/*************************************************************
此文件函数主要是虚拟rtc设备的实现
应用于不外挂晶振的场景,用户可以忽略实现,
最后的应用的接口与挂晶振的接口一致
**************************************************************/
#define WRITE_ALARM BIT(1)
#define READ_ALARM BIT(5)
#define WRITE_RTC BIT(0)
#define READ_RTC BIT(4)
#define MAX_YEAR 2099
#define MIN_YEAR 2000
typedef struct _RTC_SIMULATE_VAR {
u16 crc;
struct device device;
struct sys_time sys_simulate_time;
struct sys_time sys_alarm_time;
/* OS_MUTEX mutex; */
} RTC_SIMULATE_VAR;
#define __this (&rtc_smulate_var)
static RTC_SIMULATE_VAR rtc_smulate_var sec(.vir_rtc) = {
.crc = 0xffff,
};
static u8 g_alarm_flag = 0;
static u64 sum_nsec = 0;
static void write_alarm(struct sys_time *alarm_time);
void set_alarm_default_time(struct sys_time *t)
{
t->year = 2019;
t->month = 1;
t->day = 1;
t->hour = 18;
t->min = 19;
t->sec = 00;
write_alarm(t);
}
__attribute__((weak))void alm_wakeup_isr(void);
__attribute__((weak)) void set_rtc_default_time(struct sys_time *t);
u8 rtc_get_time_vm();
u8 rtc_save_time_vm();
u8 rtc_get_alm_vm();
u8 rtc_save_alm_vm();
static u8 is_the_same_time(struct sys_time *time1, struct sys_time *time2)
{
return (time1->year == time2->year &&
time1->month == time2->month &&
time1->day == time2->day &&
time1->hour == time2->hour &&
time1->min == time2->min &&
time1->sec == time2->sec);
}
static int rtc_simulate_init(const struct dev_node *node, void *arg)
{
if (power_return_flag()) {
/* os_mutex_create(&__this->mutex); */
if (0) {
} else if (set_rtc_default_time) {
set_rtc_default_time(&__this->sys_simulate_time);
} else {
__this->sys_simulate_time.year = 2020;
__this->sys_simulate_time.month = 1;
__this->sys_simulate_time.day = 1;
__this->sys_simulate_time.hour = 0;
__this->sys_simulate_time.min = 0;
__this->sys_simulate_time.sec = 0;
}
} else {
}
rtc_get_alm_vm();
rtc_save_time_vm();
printf("rtc_simulate_init: %d-%d-%d %d:%d:%d\n",
__this->sys_simulate_time.year,
__this->sys_simulate_time.month,
__this->sys_simulate_time.day,
__this->sys_simulate_time.hour,
__this->sys_simulate_time.min,
__this->sys_simulate_time.sec);
/* set_alarm_default_time(&__this->sys_alarm_time); */
return 0;
}
static int rtc_simulate_open(const char *name, struct device **device, void *arg)
{
*device = &__this->device;
return 0;
}
static void write_alarm(struct sys_time *alarm_time)
{
local_irq_disable();
memcpy(&__this->sys_alarm_time, alarm_time, sizeof(struct sys_time));
rtc_save_alm_vm();
local_irq_enable();
}
static void read_alarm(struct sys_time *alarm_time)
{
local_irq_disable();
rtc_get_alm_vm();
memcpy(alarm_time, &__this->sys_alarm_time, sizeof(struct sys_time));
local_irq_enable();
}
static void write_sys_time(struct sys_time *curr_time)
{
local_irq_disable();
memcpy(&__this->sys_simulate_time, curr_time, sizeof(struct sys_time));
local_irq_enable();
}
static void read_sys_time(struct sys_time *curr_time)
{
local_irq_disable();
memcpy(curr_time, &__this->sys_simulate_time, sizeof(struct sys_time));
local_irq_enable();
}
static void set_alarm_ctrl(u8 set_alarm)
{
g_alarm_flag = set_alarm;
}
static int rtc_simulate_ioctl(struct device *device, u32 cmd, u32 arg)
{
int err = 0;
switch (cmd) {
case IOCTL_SET_ALARM:
write_alarm((struct sys_time *)arg);
break;
case IOCTL_GET_ALARM:
read_alarm((struct sys_time *)arg);
break;
case IOCTL_SET_ALARM_ENABLE:
if (arg) {
set_alarm_ctrl(1);
} else {
set_alarm_ctrl(0);
}
break;
case IOCTL_GET_SYS_TIME:
read_sys_time((struct sys_time *)arg);
break;
case IOCTL_SET_SYS_TIME:
write_sys_time((struct sys_time *)arg);
break;
}
return err;
}
u8 rtc_save_time_vm()
{
u8 ret = syscfg_write(VM_VIR_RTC_TIME, &__this->sys_simulate_time, sizeof(struct sys_time));
return ret;
}
u8 rtc_get_time_vm()
{
u8 ret = syscfg_read(VM_VIR_RTC_TIME, &__this->sys_simulate_time, sizeof(struct sys_time));
return ret;
}
u8 rtc_save_alm_vm()
{
u8 ret = syscfg_write(VM_VIR_ALM_TIME, &__this->sys_alarm_time, sizeof(struct sys_time));
return ret;
}
u8 rtc_get_alm_vm()
{
u8 ret = syscfg_read(VM_VIR_ALM_TIME, &__this->sys_alarm_time, sizeof(struct sys_time));
return ret;
}
u8 rtc_get_sum_nsec_vm()
{
u8 ret = syscfg_read(VM_VIR_SUM_NSEC, &sum_nsec, 8);
return ret;
}
u8 rtc_save_sum_nsec_vm()
{
u8 ret = syscfg_read(VM_VIR_SUM_NSEC, &sum_nsec, 8);
return ret;
}
void set_virtual_rtc_tick(u64 actual_ns)
{
#if (defined(TCFG_USE_VIRTUAL_RTC) && (TCFG_USE_VIRTUAL_RTC))
struct sys_time temp_time;
static u8 cal_flag = 0;
sum_nsec += actual_ns;
if (sum_nsec >= 1000000000) {
sum_nsec -= 1000000000;
cal_flag = 1;
}
if (cal_flag) {
cal_flag = 0;
read_sys_time(&temp_time);
if (++temp_time.sec >= 60) {
temp_time.sec = 0;
if (++temp_time.min >= 60) {
temp_time.min = 0;
if (++temp_time.hour >= 24) {
temp_time.hour = 0;
if (++temp_time.day > month_for_day(temp_time.month, temp_time.year)) {
temp_time.day = 1;
if (++temp_time.month > 12) {
temp_time.month = 1;
if (++temp_time.year > MAX_YEAR) {
temp_time.year = MIN_YEAR;
}
}
}
}
}
}
write_sys_time(&temp_time);
/* printf("rtc_sys_time: %d-%d-%d %d:%d:%d\n", */
/* temp_time.year, */
/* temp_time.month, */
/* temp_time.day, */
/* temp_time.hour, */
/* temp_time.min, */
/* temp_time.sec); */
local_irq_disable();
/* rtc_get_alm_vm(); */
if (g_alarm_flag && is_the_same_time(&__this->sys_alarm_time, &__this->sys_simulate_time)) {
local_irq_enable();
if (alm_wakeup_isr) {
alm_wakeup_isr();
}
} else {
local_irq_enable();
}
}
#endif
}
extern void vir_rtc_get_actual_time(u64 *actual_time);
void vir_rtc_trim()
{
u64 actual_time;
vir_rtc_get_actual_time(&actual_time);
u32 sec = actual_time / 1000000000;
u32 min = sec / 60;
sec = sec % 60;
u32 hour = min / 60;
min = min % 60;
struct sys_time temp_time;
rtc_get_time_vm();
read_sys_time(&temp_time);
temp_time.sec += sec;
if (temp_time.sec >= 60) {
temp_time.min++;
temp_time.sec -= 60;
}
temp_time.min += min;
if (temp_time.min >= 60) {
temp_time.hour++;
temp_time.min -= 60;
}
temp_time.hour += hour;
if (temp_time.hour >= 24) {
temp_time.day++;
temp_time.hour -= 24;
if (temp_time.day > month_for_day(temp_time.month, temp_time.year)) {
temp_time.day = 1;
if (++temp_time.month > 12) {
temp_time.month = 1;
if (++temp_time.year > MAX_YEAR) {
temp_time.year = MIN_YEAR;
}
}
}
}
write_sys_time(&temp_time);
rtc_get_sum_nsec_vm();
set_virtual_rtc_tick(actual_time % 1000000000);
printf("rtc_sys_time: %d-%d-%d %d:%d:%d\n",
temp_time.year,
temp_time.month,
temp_time.day,
temp_time.hour,
temp_time.min,
temp_time.sec);
}
u32 alm_trans_for_sec()
{
struct sys_time temp_time;
struct sys_time alm_time;
read_alarm(&alm_time);
u16 alm_day = ymd_to_day(&__this->sys_alarm_time);
/* rtc_get_time_vm(); */
read_sys_time(&temp_time);
u16 cur_day = ymd_to_day(&temp_time);
u32 alm_tmp = (alm_day << 17) | ((__this->sys_alarm_time.hour & 0x1f) << 12) | ((__this->sys_alarm_time.min & 0x3f) << 6) | (__this->sys_alarm_time.sec & 0x3f);
u32 cur_tmp = (cur_day << 17) | ((temp_time.hour & 0x1f) << 12) | ((temp_time.min & 0x3f) << 6) | (temp_time.sec & 0x3f);
if (alm_tmp < cur_tmp) {
return 0;
}
u32 day = alm_day - cur_day;
u32 hour = __this->sys_alarm_time.hour + day * 24 - temp_time.hour;
u32 min = __this->sys_alarm_time.min + hour * 60 - temp_time.min;
u32 sec = __this->sys_alarm_time.sec + min * 60 - temp_time.sec;
/* printf("alm_sec = %d\n", sec); */
return sec;
}
const struct device_operations rtc_simulate_ops = {
.init = rtc_simulate_init,
.open = rtc_simulate_open,
.ioctl = rtc_simulate_ioctl,
.read = NULL,
.write = NULL,
};
#endif
apps/usr_uart_code/usr_uart_code.c
-131
View File
@@ -1,131 +0,0 @@
#include "system/includes.h"
#include "app_config.h"
#include "asm/pwm_led.h"
#include "tone_player.h"
#include "ui_manage.h"
#include "app_main.h"
#include "app_task.h"
#include "asm/charge.h"
#include "app_power_manage.h"
#include "app_charge.h"
#include "user_cfg.h"
#include "audio.h"
#include "vm.h"
#include "bleproto.h"
#include "bleproto_api.h"
#define LOG_TAG_CONST APP
#define LOG_TAG "[APP]"
#define LOG_ERROR_ENABLE
#define LOG_DEBUG_ENABLE
#define LOG_INFO_ENABLE
/* #define LOG_DUMP_ENABLE */
#define LOG_CLI_ENABLE
#include "debug.h"
extern void usr_uart_send_cmd(u8* data,u16 len);
extern void usr_ble_send_data(u8* data,u16 len);///BLE发送接口，MTU 244
extern void usr_write_pair_info();
extern void usr_clear_pair_info();
extern void usr_mcu_data_recieve(const unsigned char* hex_array, int array_length);
// 计算校验和并验证
static int verify_checksum(const unsigned char* packet_data, int length)
{
unsigned int calculated_checksum = 0;
calculated_checksum=0;
// 从帧头开始计算到倒数第二个字节的和
for (int i = 0; i < length; i++) {
calculated_checksum += packet_data[i];
}
// 对256取余
calculated_checksum %= 256;
return calculated_checksum;
}
const u8 check_mcu[7]={0x55,0xAA,0x00,0x08,0x00,0x00,0x07};
void usr_check_mcu_all_sta()///查询 mcu 工作状态,MCU上报所有DP点数值(用做APP显示)
{
usr_uart_send_cmd(check_mcu,7);
}
const u8 set_default[12]={0x55 ,0xAA ,0x00 ,0x06 ,0x00 ,0x05 ,0x18 ,0x01 ,0x00 ,0x01 ,0x01 ,0x24};
void usr_set_device_default()
{
usr_uart_send_cmd(check_mcu,12);
}
static u8 set_led_sta[12]={0x55 ,0xAA ,0x00 ,0x06 ,0x00 ,0x05 ,0x11 ,0x01 ,0x00 ,0x01 ,0xff ,0xff};
void usr_set_led_sta(u8 flag)
{
if(flag)set_led_sta[10]=0x01;
else set_led_sta[10]=0x00;
set_led_sta[11]=verify_checksum(set_led_sta,11);
usr_uart_send_cmd(set_led_sta,12);
}
/*
指示WiFI状态：
0x00：Smartconfig 配网模式 (灯快闪)；
0x01：AP配网模式 (灯慢闪)；
0x02：WiFi配置成功但未连上路由(灯熄灭)；
0x04：已连上路由器且连接到云端 (灯长亮)；
*/
static u8 send_ble_sta[8]={0x55,0xAA,0x00,0x03,0x00,0x01,0xff,0xff};
void usr_send_ble_sta(u8 flag)
{
send_ble_sta[6]=flag;
send_ble_sta[7]=verify_checksum(send_ble_sta,7);
usr_uart_send_cmd(send_ble_sta,8);
printf("usr_send_ble_sta\n");
}
//extern void usr_set_fool_val(u8 wei_cnt);
extern u8 usr_weishi_type;
extern u8 usr_weishi_fenshu;
static u8 weishi_mcu[15]={0x55,0xAA,0x00,0x06 ,0x00 ,0x08 ,0x03 ,0x02 ,0x00 ,0x04 ,0x00 ,0x00 ,0x00 ,0x02 ,0xFF};
void usr_set_werishi(int cnt,u8 weishi_type)
{
if(cnt>0)
{
//usr_set_fool_val(cnt);
usr_weishi_type=weishi_type;
usr_weishi_fenshu=cnt;
weishi_mcu[13]=cnt;
weishi_mcu[14]=verify_checksum(weishi_mcu,14);
printf("weishi cnt = %d\n",weishi_mcu[13]);
printf("checksum = %x\n",weishi_mcu[14]);
usr_uart_send_cmd(weishi_mcu,15);
}
}
extern void usr_clear_pair_info();
const u8 reset_ble[7] = {0x55,0xAA,0x03,0x04,0x00,0x00,0x06};
const u8 ble_reset_rsp[7] = {0x55,0xAA,0x00,0x04,0x00,0x00,0x03};
const u8 ble_le_sta_rsp[7] = {0x55,0xAA,0x03,0x03,0x00,0x00,0x05};
void usr_uart_data_recieve(u8* data,u16 len)///UART数据接收
{
// log_info("uart_recieve: ");
// printf_buf(data, len);
if(!memcmp(reset_ble,data,7))
{
usr_uart_send_cmd(ble_reset_rsp,7);
usr_clear_pair_info();
return;
}
if(!memcmp(ble_le_sta_rsp,data,7))
{
return;
}
usr_mcu_data_recieve(data,len);
}
apps/usr_uart_code/usr_uart_data_ana.c
-241
View File
@@ -1,241 +0,0 @@
#include <stdio.h>
#include <string.h>
#define MAX_PACKETS 12 // 最大包数量
#define MAX_PACKET_LEN 128 // 单个包的最大长度
typedef struct {
unsigned char data[MAX_PACKET_LEN]; // 包的数据
int length; // 包的长度(包括帧头和校验和)
int data_length; // 数据部分的长度(不包括帧头和校验和)
int valid; // 校验是否通过
} Packet;
typedef struct {
Packet packets[MAX_PACKETS]; // 解析出的包数组
int count; // 解析出的包数量
int valid_count; // 校验通过的包数量
} PacketResult;
// 计算校验和并验证
int verify_checksum(const unsigned char* packet_data, int length) {
if (length < 3) return 0; // 至少要有帧头+1数据+1校验和
unsigned char calculated_checksum = 0;
// 从帧头开始计算到倒数第二个字节的和
for (int i = 0; i < length - 1; i++) {
calculated_checksum += packet_data[i];
}
// 对256取余
calculated_checksum %= 256;
// 比较计算值和包中的校验和(最后一个字节)
return (calculated_checksum == packet_data[length - 1]);
}
void parse_packets(const unsigned char* hex_array, int array_length, PacketResult* result) {
result->count = 0;
result->valid_count = 0;
int start_index = -1;
for (int i = 0; i < array_length - 1 && result->count < MAX_PACKETS; i++) {
if (hex_array[i] == 0x55 && hex_array[i + 1] == 0xAA) {
if (start_index != -1) {
// 保存上一个包的信息
int packet_length = i - start_index;
if (packet_length > MAX_PACKET_LEN) {
packet_length = MAX_PACKET_LEN; // 截断超长包
}
// 复制数据
memcpy(result->packets[result->count].data,
hex_array + start_index,
packet_length);
// 设置包信息
result->packets[result->count].length = packet_length;
result->packets[result->count].data_length = packet_length - 3; // 减去帧头和校验和
// 验证校验和
result->packets[result->count].valid = verify_checksum(
result->packets[result->count].data,
packet_length);
if (result->packets[result->count].valid) {
result->valid_count++;
}
result->count++;
}
start_index = i;
}
}
// 处理最后一个包
if (start_index != -1 && start_index < array_length && result->count < MAX_PACKETS) {
int packet_length = array_length - start_index;
if (packet_length > MAX_PACKET_LEN) {
packet_length = MAX_PACKET_LEN;
}
// 复制数据
memcpy(result->packets[result->count].data,
hex_array + start_index,
packet_length);
// 设置包信息
result->packets[result->count].length = packet_length;
result->packets[result->count].data_length = packet_length - 3;
// 验证校验和
result->packets[result->count].valid = verify_checksum(
result->packets[result->count].data,
packet_length);
if (result->packets[result->count].valid) {
result->valid_count++;
}
result->count++;
}
}
void usr_tuya_data_ana(const unsigned char* data,int len);
void usr_mcu_data_recieve(const unsigned char* hex_array, int array_length)
{
PacketResult result;
parse_packets(hex_array,array_length,&result);
printf("Total packets parsed: %d\n", result.count);
printf("Valid packets: %d\n", result.valid_count);
for (int i = 0; i < result.count; i++) {
printf("\nPacket %d: Length=%d, Data Length=%d, Valid=%s\n", i+1,
result.packets[i].length,
result.packets[i].data_length,
result.packets[i].valid ? "Yes" : "No");
if (result.packets[i].valid) {
printf("Data: ");
printf_buf(result.packets[i].data, result.packets[i].length);
usr_tuya_data_ana(result.packets[i].data,result.packets[i].length);
printf("\n");
} else {
printf("Invalid checksum - Packet ignored\n");
}
}
}
//void usr_set_fool_val(unsigned char wei_cnt);
extern void usr_data_notify_auto();
extern unsigned char usr_weishi_type;
extern unsigned char usr_weishi_fenshu;
extern void usr_weishi_notify();
extern unsigned char usr_led_on_flag;
void usr_tuya_data_ana(const unsigned char* data,int len)
{
switch(data[6])///DP ID
{
case 0x01:///喂食计划
break;
case 0x02:///一键喂食
break;
case 0x03:///手动喂食
break;
case 0x04:///喂食状态
switch(data[10])
{
case 0x00:///就绪
usr_weishi_type=0;
usr_weishi_fenshu=1;
usr_data_notify_auto();
break;
case 0x01:///正在喂食
// usr_set_fool_val(usr_weishi_fenshu);
// usr_weishi_notify();
break;
case 0x02:///喂食结束
usr_weishi_type=0;
usr_weishi_fenshu=1;
break;
default:
break;
}
break;
case 0x0a:///电池电量
///电池电量=data[13];
break;
case 0x0b:///充电状态
///充电状态=data[10]
break;
case 0x0d:///故障上报
///故障=data[10]
/*
bit0:food_jam
bit1:food_shortages
bit2:food_run_out
bit3:desiccant
bit4:battery_low
bit5:device_stuck
*/
break;
case 0x0e:///喂食结果上报
break;
case 0x11:///状态指示灯应答
///LED开关=data[10]
usr_led_on_flag=data[10];
break;
case 0x17:///慢放投喂
break;
case 0x18:///恢复出厂设置应答
break;
case 0x1c:///MCU获取BLE模块的本地时间
break;
default:
break;
}
}
/*
int ana_demo() {
// 示例数据
unsigned char hex_data[] = {
0x55, 0xAA, 0x03, 0x07, 0x00, 0x0E, 0x01, 0x00, 0x00, 0x0A, 0x7F, 0x0F, 0x26, 0x01, 0x01, 0x7F, 0x0F, 0x28, 0x01, 0x01, 0x90,
0x55, 0xAA, 0x03, 0x07, 0x00, 0x08, 0x03, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x1B,
0x55, 0xAA, 0x03, 0x07, 0x00, 0x05, 0x04, 0x04, 0x00, 0x01, 0x00, 0x17,
0x55, 0xAA, 0x03, 0x07, 0x00, 0x08, 0x0A, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x21,
0x55, 0xAA, 0x03, 0x07, 0x00, 0x05, 0x0D, 0x05, 0x00, 0x01, 0x00, 0x21,
0x55, 0xAA, 0x03, 0x07, 0x00, 0x05, 0x11, 0x01, 0x00, 0x01, 0x01, 0x22,
0x55, 0xAA, 0x03, 0x07, 0x00, 0x05, 0x17, 0x01, 0x00, 0x01, 0x00, 0x87,
0x55, 0xAA, 0x03, 0x1C, 0x00, 0x00, 0x17
};
int data_length = sizeof(hex_data) / sizeof(hex_data[0]);
PacketResult result;
parse_packets(hex_data, data_length, &result);
printf("Total packets parsed: %d\n", result.count);
printf("Valid packets: %d\n", result.valid_count);
for (int i = 0; i < result.count; i++) {
printf("\nPacket %d: Length=%d, Data Length=%d, Valid=%s\n", i+1,
result.packets[i].length,
result.packets[i].data_length,
result.packets[i].valid ? "Yes" : "No");
if (result.packets[i].valid) {
printf("Data: ");
printf_buf(result.packets[i].data, result.packets[i].length);
printf("\n");
} else {
printf("Invalid checksum - Packet ignored\n");
}
}
return 0;
}
*/
apps/usr_utc/usr_plan.c
-711
View File
@@ -1,711 +0,0 @@
#include "app_config.h"
#include "key_event_deal.h"
#include "system/includes.h"
#include "tone_player.h"
#include "app_task.h"
#include "tone_player.h"
#include "media/includes.h"
#include "system/sys_time.h"
#include "ui/ui_api.h"
#include "clock_cfg.h"
#include "ui/ui_style.h"
#include "ui_manage.h"
#include "app_main.h"
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include "printf.h"
#define MAX_ENTRIES 10
#define ENTRY_LENGTH 17
typedef struct {
bool weekdays[7]; // 周一到周日，true表示有效
int start_hour; // 开始时间(小时)
int start_minute; // 开始时间(分钟)
int end_hour; // 结束时间(小时)
int end_minute; // 结束时间(分钟)
bool is_valid; // 数据是否有效
} TimeSlot;
typedef struct {
TimeSlot slots[MAX_ENTRIES];
int count;
} TimeSlotResult;
// 星期枚举 - 按照周一到周日排列(1-7)
typedef enum {
MONDAY = 1,
TUESDAY,
WEDNESDAY,
THURSDAY,
FRIDAY,
SATURDAY,
SUNDAY
} Weekday;
extern uint32_t convertToUtcTimestamp(uint16_t year, uint8_t month, uint8_t day,uint8_t hour, uint8_t minute, uint8_t second);
extern void usr_plan_dec(u8* data,u8 cur_hour,u8 cur_min,u8 cur_week);
// 星期几转换为字符串
const char* weekdayNames[] = {"", "Monday", "Tuesday", "Wednesday",
"Thursday", "Friday", "Saturday", "Sunday"};
///"1000001+0928+3+1"
u8 usr_we_plan_table[170];
struct sys_time usr_current_time;
struct sys_time usr_set_time;
// 将两个字符转换为数字
static int parse_two_digits(const char* str) {
if (!isdigit(str[0])) return -1;
if (!isdigit(str[1])) return -1;
return (str[0] - '0') * 10 + (str[1] - '0');
}
// 解析单个时间区间数据
bool parse_single_entry(const char* data, TimeSlot* slot) {
// 检查终止符
if (data[0] == 0xFF) {
return false;
}
// 初始化结构体
memset(slot, 0, sizeof(TimeSlot));
slot->is_valid = true;
// 解析周一到周日有效性 (前7位)
for (int i = 0; i < 7; i++) {
if (data[i] != '0' && data[i] != '1') {
slot->is_valid = false;
return true;
}
slot->weekdays[i] = (data[i] == '1');
}
// 检查分隔符
if (data[7] != '+' || data[12] != '+') {
slot->is_valid = false;
return true;
}
// 解析开始时间 (第8-11位，格式1828)
slot->start_hour = parse_two_digits(data + 8);
slot->start_minute = parse_two_digits(data + 10);
// 解析结束时间 (第13-16位，格式1930)
slot->end_hour = parse_two_digits(data + 13);
slot->end_minute = parse_two_digits(data + 15);
// 验证时间有效性
if (slot->start_hour < 0 || /*slot->start_hour >= 24 ||*/
slot->start_minute < 0 || slot->start_minute >= 60 ||
slot->end_hour < 0 || /*slot->end_hour >= 24 ||*/
slot->end_minute < 0 || slot->end_minute >= 60) {
printf("!!!!!!!!!!!!!1 time invalid\n");
slot->is_valid = false;
}
return true;
}
// 解析时间区间数据数组
void parse_time_slots(const unsigned char* data, int data_length, TimeSlotResult* result) {
result->count = 0;
// 检查输入数据长度是否合理
if (data_length < ENTRY_LENGTH || data_length > MAX_ENTRIES * ENTRY_LENGTH) {
printf("!!!!!!!!!!invalid date1\n");
return;
}
// 解析每组数据
for (int i = 0; i < MAX_ENTRIES; i++) {
int offset = i * ENTRY_LENGTH;
// 检查是否超出数据范围
if (offset + ENTRY_LENGTH > data_length) {
printf("!!!!!!!!!!invalid date2\n");
return;
}
// 检查终止符
if (data[offset] == 0xFF) {
//printf("!!!!!!!!!!date end\n");
return;
}
// 解析单个条目
if (!parse_single_entry((const char*)(data + offset), &result->slots[result->count])) {
return;
}
// 只有有效数据才计数
if (result->slots[result->count].is_valid) {
result->count++;
}
}
}
// 打印时间区间信息
void print_time_slot(const TimeSlot* slot) {
const char* weekday_names[] = {" WEEK1", "WEEK2", "WEEK3", "WEEK4", "WEEK5", "WEEK6", "WEEK7"};
printf("WEEK: ");
int valid_days = 0;
for (int i = 0; i < 7; i++) {
if (slot->weekdays[i]) {
printf("%s ", weekday_names[i]);
valid_days++;
}
}
if (valid_days == 0) {
printf("unknown");
}
printf("\ntime: %02d:%02d - %02d:%02d\n",
slot->start_hour, slot->start_minute,
slot->end_hour, slot->end_minute);
}
int plan_test_main() {
// 示例数据 (170字节数组，实际只填充部分数据)
unsigned char test_data[170] = {
'0','0','0','0','0','0','1','+','1','8','2','8','+','1','9','3','0', // 条目1
'1','0','0','0','0','0','0','+','0','8','0','0','+','1','2','0','0', // 条目2
'0','1','0','0','0','0','0','+','1','3','0','0','+','1','7','3','0', // 条目3
'0','0','0','0','0','0','0','+','1','8','2','8','+','1','9','3','0',
'1','1','1','1','1','1','1','+','1','2','2','4','+','2','3','3','0',
0xFF, // 终止符
// 剩余数据...
};
TimeSlotResult result = {0};
parse_time_slots(test_data, sizeof(test_data), &result);
printf("total num %d :\n", result.count);
for (int i = 0; i < result.count; i++) {
printf("\nnum %d:\n", i+1);
print_time_slot(&result.slots[i]);
}
return 0;
}
// 计算某年某月某日是星期几（返回1-7对应周一到周日）
uint8_t calculateWeekday(uint16_t year, uint8_t month, uint8_t day)
{
// 如果月份是1月或2月，当作前一年的13月或14月
if (month < 3) {
month += 12;
year -= 1;
}
uint16_t century = year / 100;
uint16_t yearInCentury = year % 100;
// Zeller公式
// h = (q + [(13(m+1))/5] + K + K/4 + J/4 + 5J) mod 7
// h是星期几(0=周六,1=周日,2=周一,...,6=周五)
uint16_t h = (day + (13 * (month + 1)) / 5 + yearInCentury + yearInCentury / 4 + century / 4 + 5 * century) % 7;
// 转换为1=周一,2=周二,...,7=周日
uint8_t weekday = (h + 5) % 7 + 1;
return weekday;
}
void usr_get_sys_time()//获取时间
{
u8 usr_week_data=0;
/*if (!__this->dev_handle) {
return ;
}*/
//if(usr_time_set_flag==0)return;
//dev_ioctl(__this->dev_handle, IOCTL_GET_SYS_TIME, (u32)&usr_current_time);
read_sys_time(&usr_current_time);
usr_week_data=calculateWeekday(usr_current_time.year,usr_current_time.month,usr_current_time.day);
/*printf("time: %d-%d-%d %d:%d:%d",
usr_current_time.year,
usr_current_time.month,
usr_current_time.day,
usr_current_time.hour,
usr_current_time.min,
usr_current_time.sec);*/
//printf("Day of week: %s\n", weekdayNames[usr_week_data]);
if((usr_current_time.year<2025)||(usr_current_time.year>2098))return;
usr_var.usr_cureent_utc=convertToUtcTimestamp(usr_current_time.year,usr_current_time.month,usr_current_time.day,usr_current_time.hour,usr_current_time.min,usr_current_time.sec);
if(usr_var.usr_cureent_utc)
{
if(usr_var.usr_cureent_utc>usr_var.usr_timezoneOffset)usr_var.usr_cureent_utc=usr_var.usr_cureent_utc-usr_var.usr_timezoneOffset;
}
/*
0000001+1828+05+1
1000001+0928+03+1
1100000+1328+02+0
0000000+1032+01+1
*/
//if(usr_time_set_flag)
{
usr_plan_dec(usr_we_plan_table,usr_current_time.hour,usr_current_time.min,usr_week_data);
}
}
void usr_set_sys_time()//设置时间
{
/*usr_set_time.year=data_time->year;
usr_set_time.month=data_time->month;
usr_set_time.day=data_time->day;
usr_set_time.hour=data_time->hour;
usr_set_time.min=data_time->minute;
usr_set_time.sec=data_time->second;*/
//dev_ioctl(__this->dev_handle, IOCTL_SET_SYS_TIME, (u32)&usr_set_time);
write_sys_time(&usr_set_time);
//dev_ioctl(__this->dev_handle, IOCTL_GET_SYS_TIME, (u32)&usr_current_time);
read_sys_time(&usr_current_time);
usr_current_time.year=usr_set_time.year;
usr_current_time.month=usr_set_time.month;
usr_current_time.day=usr_set_time.day;
usr_current_time.hour=usr_set_time.hour;
usr_current_time.min=usr_set_time.min;
usr_current_time.sec=usr_set_time.sec;
usr_var.usr_cureent_utc=convertToUtcTimestamp(usr_current_time.year,usr_current_time.month,usr_current_time.day,usr_current_time.hour,usr_current_time.min,usr_current_time.sec);
if(usr_var.usr_cureent_utc)
{
if(usr_var.usr_cureent_utc>usr_var.usr_timezoneOffset)usr_var.usr_cureent_utc=usr_var.usr_cureent_utc-usr_var.usr_timezoneOffset;
}
printf("##### usr_var.usr_cureent_utc = %d\n",usr_var.usr_cureent_utc);
}
void usr_rtc_get_time()
{
usr_get_sys_time();
}
///"1000001+0928+3+1"
void usr_read_plan()
{
int ret=0;
u8 default_str[]={'1','1','1','1','1','1','1','+','2','2','0','0','+','0','6','0','0',};
//i=CFG_USER_PLAN_INFO1;
printf("usr_read_plan start\n");
ret = syscfg_read(CFG_USER_PLAN_INFO1,usr_we_plan_table,170);
printf("ret = %d\n",ret);
if(ret<=0)
{
memset(usr_we_plan_table,0xff,170);
memcpy(usr_we_plan_table,default_str,17);
syscfg_write(CFG_USER_PLAN_INFO1,usr_we_plan_table,170);
}
for(u8 i=0;i<5;i++)
{
printf_buf(&usr_we_plan_table[i*17],17);
}
printf("usr_read_plan end\n");
}
void usr_clear_plan()
{
u8 default_str[]={'1','1','1','1','1','1','1','+','2','2','0','0','+','0','6','0','0',};
memset(usr_we_plan_table,0xff,170);
memcpy(usr_we_plan_table,default_str,17);
syscfg_write(CFG_USER_PLAN_INFO1,usr_we_plan_table,170);
}
void usr_write_plan(u8 write_num,u8*data)
{
memcpy(&usr_we_plan_table[write_num*17],data,17);
//printf("w data:");
//printf_buf(data,17);
//memcpy(&usr_we_plan_table[write_num][0],data,17);
}
void usr_write_plan_to_vm()
{
syscfg_write(CFG_USER_PLAN_INFO1,usr_we_plan_table,170);
}
void usr_plan_init()
{
// usr_clear_min_cache();
// rtc_task_start();
usr_read_plan();
usr_var.usr_timezoneOffset=0;
}
/*
typedef struct {
bool weekdays[7]; // 周一到周日，true表示有效
int start_hour; // 开始时间(小时)
int start_minute; // 开始时间(分钟)
int end_hour; // 结束时间(小时)
int end_minute; // 结束时间(分钟)
bool is_valid; // 数据是否有效
} TimeSlot;
typedef struct {
TimeSlot slots[MAX_ENTRIES];
int count;
} TimeSlotResult;
*/
// 更通用的版本，可以指定任意开始和结束时间
int isWithinCustomTimeRange(u16 cur_hour,u16 cur_min,u16 start_hour,u16 start_min,u16 end_hour,u16 end_min) {
// 将当前时间转换为总分钟数
int current_minutes = cur_hour * 60 + cur_min;
// 将开始时间和结束时间转换为总分钟数
int start_minutes = start_hour * 60 + start_min;
int end_minutes = end_hour * 60 + end_min;
// 判断时间段是否跨天
int crosses_midnight = (start_minutes > end_minutes);
if (crosses_midnight) {
// 跨天的情况
if (current_minutes >= start_minutes || current_minutes < end_minutes) {
return 1;
} else {
return 0;
}
} else {
// 不跨天的情况
if (current_minutes >= start_minutes && current_minutes < end_minutes) {
return 1;
} else {
return 0;
}
}
}
void usr_plan_dec(u8* data,u8 cur_hour,u8 cur_min,u8 cur_week)
{
TimeSlotResult result = {0};
parse_time_slots(data, 170, &result);
if(result.count>1)result.count=1;
usr_var.usr_plan_cnt=result.count;
u8 i=0;
if(_usr_module_cfg.wuraomoshi_onoff==0)
{
usr_var.usr_disable_zjhendong=0;
return;
}
if((result.slots[i].start_hour==0)&&(result.slots[i].end_hour==0))
{
usr_var.usr_disable_zjhendong=1;
return ;
}
if((result.slots[i].start_hour==0)&&(result.slots[i].end_hour==24))
{
usr_var.usr_disable_zjhendong=1;
return ;
}
if((result.slots[i].start_hour==24)&&(result.slots[i].end_hour==0))
{
usr_var.usr_disable_zjhendong=1;
return ;
}
if((result.slots[i].start_hour==24)&&(result.slots[i].end_hour==24))
{
usr_var.usr_disable_zjhendong=1;
return ;
}
//printf("total num %d :\n", result.count);
for (u8 i = 0; i < result.count; i++)
{
//printf("time: %02d:%02d - %02d:%02d\n",\
// result.slots[i].start_hour, result.slots[i].start_minute,\
// result.slots[i].end_hour, result.slots[i].end_minute);
//printf("cur_week = [%d]",cur_week);
if(usr_we_plan_table[cur_week-1]==0x30)
{
usr_var.usr_disable_zjhendong=0;
return;
}
for(u8 j=0;j<7;j++)
{
if(usr_we_plan_table[j]==0x31)
{
if((j+1)==cur_week)
{
if(isWithinCustomTimeRange(cur_hour,cur_min,result.slots[i].start_hour,result.slots[i].start_minute,\
result.slots[i].end_hour,result.slots[i].end_minute))
{
//putchar('1');
usr_var.usr_disable_zjhendong=1;
}
else
{
//putchar('0');
usr_var.usr_disable_zjhendong=0;
}
}
}
}
}
//plan_test_main();
}
#if 0
u8 usr_weishi_plan_cnt=0;
void usr_plan_dec(u8* data,u8 cur_hour,u8 cur_min,u8 cur_week)
{
// 示例数据（usr_we_plan_table，包含2组有效数据+0xFF填充）
/* uint8_t usr_we_plan_table[160] = {
// 第1组: "0000001+1828+5+1"（周一执行，18:28，重复5次，启用）
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x2B,0x31, 0x38, 0x32, 0x38, 0x2B, 0x35, 0x2B, 0x31,
// 第2组: "1000001+0928+3+1"（周日和周一执行，09:28，重复3次，启用）
0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x2B,0x30, 0x39, 0x32, 0x38, 0x2B, 0x33, 0x2B, 0x31,
// 剩余部分填充0xFF（无效数据）
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
// ...（后续全部0xFF）
};*/
/*
task1: week=0x01, time=18:28, action_cnt=5, onoff=1
task2: week=0x41, time=09:28, action_cnt=3, onoff=1
task3: week=0x60, time=13:28, action_cnt=2, onoff=0
task4: week=0x00, time=10:32, action_cnt=1, onoff=1
*/
u8 usr_cur_week=0;
usr_cur_week=cur_week;
TaskConfig tasks[MAX_TASKS]; // 存储解析结果
uint8_t task_count = parse_multiple_tasks(data, tasks, MAX_TASKS);
usr_weishi_plan_cnt=task_count;
//printf("ana %d task min_cache = %d\n", task_count,min_cache);
for (uint8_t i = 0; i < task_count; i++)
{
usr_weishi_index=i;
/*printf("task%d: week=0x%02X, time=%02d:%02d, action_cnt=%d, onoff=%d\n",i + 1,
tasks[i].execute_days,
tasks[i].hour,
tasks[i].minute,
tasks[i].repeat_count,
tasks[i].is_enabled);*/
if(min_cache<0xff)
{
if(cur_min>min_cache)
{
min_cache=0xff;
}
}
if(tasks[i].execute_days==0x00)
{
if(tasks[i].is_enabled)
{
if((cur_hour==tasks[i].hour)&&(cur_min==tasks[i].minute))
{
if(min_cache!=cur_min)
{
printf("plan to feed!\n");
usr_set_werishi(tasks[i].repeat_count,1);
min_cache=cur_min;
// 修改第任务的 is_enabled 为 0（关闭）
bool success = update_task_enabled(data, &tasks[i], false);
if (success) {
printf("close task!\n");
printf("new enabled is: %d\n", tasks[i].is_enabled);
}
}
}
else
{
//min_cache=0xff;
}
}
}
switch(cur_week)
{
case 0x01:
if(tasks[i].execute_days&BIT(6))///周一有计划
{
if(tasks[i].is_enabled)
{
if((cur_hour==tasks[i].hour)&&(cur_min==tasks[i].minute))
{
if(min_cache!=cur_min)
{
printf("plan to feed!\n");
usr_set_werishi(tasks[i].repeat_count,1);
min_cache=cur_min;
}
}
else
{
//min_cache=0xff;
}
}
}
break;
case 0x02:
if(tasks[i].execute_days&BIT(5))///周二有计划
{
if(tasks[i].is_enabled)
{
if((cur_hour==tasks[i].hour)&&(cur_min==tasks[i].minute))
{
if(min_cache!=cur_min)
{
printf("plan to feed!\n");
usr_set_werishi(tasks[i].repeat_count,1);
min_cache=cur_min;
}
}
else
{
// min_cache=0xff;
}
}
}
break;
case 0x03:
if(tasks[i].execute_days&BIT(4))///周三有计划
{
if(tasks[i].is_enabled)
{
if((cur_hour==tasks[i].hour)&&(cur_min==tasks[i].minute))
{
if(min_cache!=cur_min)
{
printf("plan to feed!\n");
usr_set_werishi(tasks[i].repeat_count,1);
min_cache=cur_min;
}
}
else
{
///min_cache=0xff;
}
}
}
break;
case 0x04:
if(tasks[i].execute_days&BIT(3))///周四有计划
{
if(tasks[i].is_enabled)
{
//printf("cur_hour = %d tasks[%d].hour = %d\n",cur_hour,i,tasks[i].hour);
//printf("cur_min = %d tasks[%d].minute = %d\n",cur_min,i,tasks[i].minute);
if((cur_hour==tasks[i].hour)&&(cur_min==tasks[i].minute))
{
if(min_cache!=cur_min)
{
printf("plan to feed!\n");
usr_set_werishi(tasks[i].repeat_count,1);
min_cache=cur_min;
//printf("min_cache2 = %d\n",min_cache);
}
}
else
{
//min_cache=0xff;
//printf("min_cache3 = %d\n",min_cache);
}
}
}
break;
case 0x05:
if(tasks[i].execute_days&BIT(2))///周五有计划
{
if(tasks[i].is_enabled)
{
if((cur_hour==tasks[i].hour)&&(cur_min==tasks[i].minute))
{
if(min_cache!=cur_min)
{
printf("plan to feed!\n");
usr_set_werishi(tasks[i].repeat_count,1);
min_cache=cur_min;
}
}
else
{
//min_cache=0xff;
}
}
}
break;
case 0x06:
if(tasks[i].execute_days&BIT(1))///周六有计划
{
if(tasks[i].is_enabled)
{
if((cur_hour==tasks[i].hour)&&(cur_min==tasks[i].minute))
{
if(min_cache!=cur_min)
{
printf("plan to feed!\n");
usr_set_werishi(tasks[i].repeat_count,1);
min_cache=cur_min;
}
}
else
{
//min_cache=0xff;
}
}
}
break;
case 0x07:
if(tasks[i].execute_days&BIT(0))///周日有计划
{
if(tasks[i].is_enabled)
{
if((cur_hour==tasks[i].hour)&&(cur_min==tasks[i].minute))
{
if(min_cache!=cur_min)
{
printf("plan to feed!\n");
usr_set_werishi(tasks[i].repeat_count,1);
min_cache=cur_min;
}
}
else
{
//min_cache=0xff;
}
}
}
break;
}
}
}
#endif // 0
apps/usr_utc/usr_utc_de_en.c
-186
View File
@@ -1,186 +0,0 @@
#include "system/includes.h"
#include "app_config.h"
#include "asm/pwm_led.h"
#include "tone_player.h"
#include "ui_manage.h"
#include "app_main.h"
#include "app_task.h"
#include "asm/charge.h"
#include "app_power_manage.h"
#include "app_charge.h"
#include "user_cfg.h"
#include "audio.h"
#include "vm.h"
#include "sys_time.h"
// 定义时间结构体
typedef struct {
uint16_t year; // 年份 (1970-2106)
uint8_t month; // 月份 (1-12)
uint8_t day; // 日 (1-31)
uint8_t hour; // 时 (0-23)
uint8_t minute; // 分 (0-59)
uint8_t second; // 秒 (0-59)
} DateTime;
DateTime usr_dt;
void parseMillisecondTimestamp(int64_t timestampMs, int64_t timezoneOffset, DateTime *dt);
void usr_set_data_time(int64_t timestampMs, int64_t timezoneOffset)
{
parseMillisecondTimestamp(timestampMs,timezoneOffset,&usr_dt);
}
extern struct sys_time usr_set_time;
extern void usr_set_sys_time();//设置时间
// 判断是否为闰年
static uint8_t isLeapYear(uint16_t year) {
if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {
return 1;
}
return 0;
}
// 计算从1970年到指定年份之前的总天数
static uint32_t getDaysSinceEpoch(uint16_t year) {
uint32_t days = 0;
for (uint16_t y = 1970; y < year; y++) {
days += isLeapYear(y) ? 366 : 365;
}
return days;
}
// 获取指定年份和月份的天数
static uint8_t getDaysInMonth(uint16_t year, uint8_t month) {
const uint8_t daysInMonth[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
if (month == 2 && isLeapYear(year)) {
return 29;
}
if (month >= 1 && month <= 12) {
return daysInMonth[month - 1];
}
return 0;
}
// 解析毫秒级UTC时间戳并应用时区偏移
void parseMillisecondTimestamp(int64_t timestampMs, int64_t timezoneOffset, DateTime *dt)
{
// 转换为秒（丢弃毫秒部分）
int64_t timestamp = timestampMs ;/// 1000;
// 应用时区偏移(转换为秒)
timestamp += timezoneOffset;// * 3600;
usr_var.usr_timezoneOffset = timezoneOffset;
// 处理可能的负值
if (timestamp < 0) {
timestamp = 0;
}
uint64_t days, seconds, minutes, hours;
uint16_t year = 1970;
uint8_t month = 1;
// 计算秒、分、时
seconds = timestamp % 60;
timestamp /= 60;
minutes = timestamp % 60;
timestamp /= 60;
hours = timestamp % 24;
timestamp /= 24;
// 计算年月日
while (1) {
uint16_t daysInYear = isLeapYear(year) ? 366 : 365;
if (timestamp >= daysInYear) {
timestamp -= daysInYear;
year++;
} else {
break;
}
}
while (1) {
uint8_t daysInMonth = getDaysInMonth(year, month);
if (timestamp >= daysInMonth) {
timestamp -= daysInMonth;
month++;
} else {
break;
}
}
// 填充结构体
dt->year = year;
dt->month = month;
dt->day = (uint8_t)(timestamp + 1);
dt->hour = (uint8_t)hours;
dt->minute = (uint8_t)minutes;
dt->second = (uint8_t)seconds;
usr_set_time.year=dt->year;
usr_set_time.month=dt->month;
usr_set_time.day=dt->day;
usr_set_time.hour=dt->hour;
usr_set_time.min=dt->minute;
usr_set_time.sec=dt->second;
usr_set_sys_time();
}
/*
> 喂食计划设置请求
* 命令ID： 205
* 参数说明
| 索引 | 类型 | 描述 | 取值 |
| ---- | ------ | ------------------------------------------------------------ | ---------------------------- |
| 0 | int32 | 喂食计划个数(最多10个计划) | 0-10 |
| 0-N | string | 周计划 + 时间点 + 份数 +开关<br />周计划：ddddddd, 从左到右表示7个，分别表示周一到周日，1表示有效，0表示无效
<br />时间点：hhmm, hh表示小时，mm表示分钟<br />份数 ：n 表示份数<br />开关：x 1 表示开，0表示关<br />
例如<br />0000001+1828+5+1 表示每周日重复 +18:28+5份粮+开<br />
1000001+0928+3+1 表示每周一和周日重复+09:28+3份粮+开<br />
1100000+1328+2+0 表示每周一和周二重复+13:28+2份粮+关<br />
0000000+1032+1+1 表示单次 +10:32+1份粮+开 | 字符串<br />ddddddd+hhmm+n+x |
*/
// 示例用法
int utc_test_main() {
/* DateTime dt;
uint64_t utcTimestamp = 1747568305845; // 2024-05-18 00:00:00 UTC
int32_t timezoneOffset = 8*60*60; // 东八区(北京时间)
parseMillisecondTimestamp(utcTimestamp, timezoneOffset, &dt);
printf("utc_read_sys_time: %d-%d-%d %d:%d:%d\n",
dt.year,
dt.month,
dt.day,
dt.hour,
dt.minute,
dt.second);
// 现在dt结构体中包含解析后的本地时间信息
// dt.year = 2024
// dt.month = 5
// dt.day = 18
// dt.hour = 8 (UTC+8)
// dt.minute = 0
// dt.second = 0
*/
return 0;
}
apps/usr_utc/usr_utc_encode.c
-88
View File
@@ -1,88 +0,0 @@
#include "system/includes.h"
#include "app_config.h"
#include "asm/pwm_led.h"
#include "tone_player.h"
#include "ui_manage.h"
#include "app_main.h"
#include "app_task.h"
#include "asm/charge.h"
#include "app_power_manage.h"
#include "app_charge.h"
#include "user_cfg.h"
#include "audio.h"
#include "vm.h"
#include "sys_time.h"
#include <stdint.h>
// 判断是否为闰年
static uint8_t isLeapYear(uint16_t year) {
if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {
return 1;
}
return 0;
}
// 计算从1970年到指定年份之前的总天数
static uint32_t getDaysSinceEpoch(uint16_t year) {
uint32_t days = 0;
for (uint16_t y = 1970; y < year; y++) {
days += isLeapYear(y) ? 366 : 365;
}
return days;
}
// 计算指定年份中到指定月份之前的总天数
static uint32_t getDaysInYear(uint16_t year, uint8_t month) {
const uint8_t daysInMonth[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
uint32_t days = 0;
for (uint8_t m = 1; m < month; m++) {
days += daysInMonth[m - 1];
// 处理闰年二月
if (m == 2 && isLeapYear(year)) {
days += 1;
}
}
return days;
}
// 将日期时间转换为UTC时间戳（秒级）
// 参数范围检查：1970 <= year <= 2106, 1 <= month <= 12, 1 <= day <= 31
// 0 <= hour <= 23, 0 <= minute <= 59, 0 <= second <= 59
uint32_t convertToUtcTimestamp(uint16_t year, uint8_t month, uint8_t day,
uint8_t hour, uint8_t minute, uint8_t second) {
// 1. 计算从1970年到目标年份之前的总天数
uint32_t totalDays = getDaysSinceEpoch(year);
// 2. 加上目标年份中到目标月份之前的天数
totalDays += getDaysInYear(year, month);
// 3. 加上当月已过的天数（day-1，因为当天还没过完）
totalDays += (day - 1);
// 4. 计算总秒数
uint32_t totalSeconds = totalDays * 86400UL; // 每天86400秒
totalSeconds += hour * 3600UL; // 小时转秒
totalSeconds += minute * 60UL; // 分钟转秒
totalSeconds += second; // 加上秒
return totalSeconds;
}
// 示例用法
int utc_dec_test_main()
{
// 北京时间2025-05-19 00:38:25 (UTC时间2025-05-18 16:38:25)
/*uint32_t timestamp = convertToUtcTimestamp(2025, 5, 18, 16, 38, 25);
// 应返回1747568305 (对应的毫秒时间戳是1747568305000)
printf("UTC timestamp: %lu\n", timestamp);*/
return 0;
}