xing/plant_manage
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

解决了一些bug，添加完善了程序注释

Browse source
This commit is contained in:
forbelief 2016-06-04 16:18:10 +08:00
parent fe11958be3
commit bd1902939a
23 changed files with 7250 additions and 7073 deletions
Download patch file Download diff file Expand all files Collapse all files

3838
plan_manage_main/ewp/plan_manage_main.dep
View file

File diff suppressed because it is too large Load diff

5394
plan_manage_main/ewp/plan_manage_main.ewd
View file

File diff suppressed because it is too large Load diff

2
plan_manage_main/ewp/settings/plan_manage_main.Debug.cspy.bat
View file

@ -19,6 +19,6 @@
@REM @REM
"D:\work_soft\iar\arm\common\bin\cspybat" "D:\work_soft\iar\arm\arm\bin\armproc.dll" "D:\work_soft\iar\arm\arm\bin\armjlink.dll" %1 --plugin "D:\work_soft\iar\arm\arm\bin\armbat.dll" --device_macro "D:\work_soft\iar\arm\arm\config\debugger\Freescale\Kinetis.dmac" --backend -B "--endian=little" "--cpu=Cortex-M0+" "--fpu=None" "-p" "D:\work_soft\iar\arm\arm\CONFIG\debugger\Freescale\MKL25Z128xxx4.ddf" "--semihosting" "--device=MKL25Z128xxx4" "--drv_mtb_regbase=0xF0000000" "--drv_mtb_dwtregbase=0xF0001000" "--drv_mtb_minramaddr=0x20000000" "--drv_mtb_maxramaddr=0x20002FFF" "--drv_communication=USB0" "--jlink_speed=auto" "--jlink_initial_speed=1000" "--jlink_reset_strategy=0,0" "--jlink_interface=SWD" "--drv_catch_exceptions=0x000" "--drv_swo_clock_setup=72000000,0,2000000" "D:\work_soft\iar\arm\common\bin\cspybat" "D:\work_soft\iar\arm\arm\bin\armproc.dll" "D:\work_soft\iar\arm\arm\bin\armjlink.dll" %1 --plugin "D:\work_soft\iar\arm\arm\bin\armbat.dll" --device_macro "D:\work_soft\iar\arm\arm\config\debugger\Freescale\Kinetis.dmac" --backend -B "--endian=little" "--cpu=Cortex-M0+" "--fpu=None" "-p" "D:\work_soft\iar\arm\arm\CONFIG\debugger\Freescale\MKL25Z128xxx4.ddf" "--drv_attach_to_program" "--semihosting" "--device=MKL25Z128xxx4" "--drv_mtb_regbase=0xF0000000" "--drv_mtb_dwtregbase=0xF0001000" "--drv_mtb_minramaddr=0x20000000" "--drv_mtb_maxramaddr=0x20002FFF" "--drv_communication=USB0" "--jlink_speed=auto" "--jlink_initial_speed=1000" "--jlink_reset_strategy=0,0" "--jlink_interface=SWD" "--drv_catch_exceptions=0x000" "--drv_swo_clock_setup=72000000,0,2000000"

2
plan_manage_main/ewp/settings/plan_manage_main.dni
View file

@ -9,7 +9,7 @@ TriggerName=main
LimitSize=0 LimitSize=0
ByteLimit=50 ByteLimit=50
[DebugChecksum] [DebugChecksum]
Checksum=231404021 Checksum=2097835749
[CodeCoverage] [CodeCoverage]
Enabled=_ 0 Enabled=_ 0
[Exceptions] [Exceptions]

BIN
plan_manage_main/res/pm_tft_001.HMI
View file

Binary file not shown.

98
plan_manage_main/src/app/include/key.h
View file

@ -1,58 +1,40 @@
/* key.h - 监测并采集按键的输入 /* key.h - 监测并采集按键的输入
* 共有四种输入，无键，单击，双击，长击。 * 共有四种输入，无键，单击，双击，长击。
* 使用一个定时器每10ms采集一次io状态来实现的。 * 使用一个定时器每10ms采集一次io状态来实现的。
*/ */
#ifndef KEY_H #ifndef KEY_H
#define KEY_H #define KEY_H
typedef enum key_mean_ /*
{ * key_mean - 按键的状态标志符号
N_KEY = 0, S_KEY, D_KEY, L_KEY * N_KEY表示无键按下状态，S_KEY表示单击，D_KEY表示双击，L_KEY表示长按
} key_mean; */
typedef enum key_mean_
{
N_KEY = 0, S_KEY, D_KEY, L_KEY
/* } key_mean;
* key_type - 按键的种类
*/
typedef enum key_type_
{ /*
UP_KEY = 0, DOWN_KEY, OK_KEY, RET_KEY, AMS_KEY, WIFI_KEY, MR_KEY, MB_KEY, MUVB_KEY * key_type - 按键的种类
} key_type; */
typedef enum key_type_
{
UP_KEY = 0, DOWN_KEY, OK_KEY, RET_KEY, AMS_KEY, WIFI_KEY, MR_KEY, MB_KEY, MUVB_KEY
/* } key_type;
* key_init() - 按键模块初始化
*
*/
void key_init(void);
void key_init(void);
void key_detect(void);
/* key_mean get_key_mean(key_type key_t);
* key_detect() - 检测按键 void clear_key_m(void);
*
* 要求每隔10ms调用一次
*/
void key_detect(void);
#endif // KEY_H
/*
* get_key_mean() - 得到指定的按键信息
*
* 这个函数中在取得信息后会将对应按键重新标记为N_KEY
*/
key_mean get_key_mean(key_type key_t);
void clear_key_m(void);
#endif // KEY_H

85
plan_manage_main/src/app/include/knob.h
View file

@ -1,56 +1,29 @@
/* /*
* knob.h - 提供旋钮输入的接口函数 * knob.h - 提供旋钮输入的接口函数
* *
* 使用的是一个数字旋钮，利用计数来采集输入 * 使用的是一个数字旋钮，利用计数来采集输入
*/ */
#ifndef KNOB_H #ifndef KNOB_H
#define KNOB_H #define KNOB_H
#include "arm_cm0.h"
#include "vectors.h"
void knob_init(void);
/*
* knob_init() - 为旋钮输入而执行的初始化
* void knob_enable(void);
* 旋钮的检测初始化后默认是禁止的
*/ void knob_disable(void);
void knob_init(void);
void knob_clear(void);
int32_t get_knob_val(void);
/*
* knob_enable() - 使能旋钮脉冲检测 void knob_detect(void);
*/
void knob_enable(void);
#endif /* KNOB_H */
/*
* knob_disable() - 禁止旋钮脉冲检测
*/
void knob_disable(void);
/*
* knob_clear() - 清除旋钮值
*/
void knob_clear(void);
/*
* get_knob_val() - 返回旋钮值
*/
int32_t get_knob_val(void);
/*
* knob_detect() - 旋钮检测
*
* 这个函数需要在旋钮编码器的A相输出发生沿跳变时调用，即上下沿中断时
*/
void knob_detect(void);
#endif /* KNOB_H */

72
plan_manage_main/src/app/include/pm_time.h
View file

@ -1,38 +1,34 @@
/* /*
* time.h - 时间处理 * time.h - 时间处理
*/ */
#include <stdint.h> #include <stdint.h>
typedef struct calendar_info_ /*
{ * calendar_info - 分解时间
uint8_t sec; */
uint8_t min; typedef struct calendar_info_
uint8_t hour; {
uint8_t mday; uint8_t sec;
uint8_t month; uint8_t min;
uint16_t year; uint8_t hour;
uint8_t wday; uint8_t mday;
uint16_t yday; uint8_t month;
} calendar_info; uint16_t year;
uint8_t wday;
enum { START_YEAR = 2000, SEC_IN_DAY = 24 * 60 * 60}; uint16_t yday;
} calendar_info;
uint8_t is_leapyear(uint16_t year);
// START_YEAR为计算日历时间时的起始时间
uint8_t get_month_days(uint16_t year, uint8_t month); enum { START_YEAR = 2000, SEC_IN_DAY = 24 * 60 * 60};
void ds1302_init(void); uint8_t is_leapyear(uint16_t year);
uint8_t get_month_days(uint16_t year, uint8_t month);
void ds1302_set_time(calendar_info *cal); void ds1302_init(void);
void ds1302_set_time(calendar_info *cal);
void ds1302_read_time(calendar_info *cal); void ds1302_read_time(calendar_info *cal);
void maintain_system_time(void);
void maintain_system_time(void); calendar_info get_system_time(void);
uint32_t calendar_to_sec(calendar_info *cal);
calendar_info get_system_time(void); calendar_info sec_to_calendar(uint32_t sec);
uint32_t calendar_to_sec(calendar_info *cal);
calendar_info sec_to_calendar(uint32_t sec);

159
plan_manage_main/src/app/include/simulat_timer.h
View file

@ -1,107 +1,52 @@
/* /*
* simulat_timer.h - 实现一个模拟定时器 * simulat_timer.h - 实现一个模拟定时器
*/ */
#ifndef SIMULAT_TIMER_H #ifndef SIMULAT_TIMER_H
#define SIMULAT_TIMER_H #define SIMULAT_TIMER_H
#include <stdint.h> #include <stdint.h>
/* /*
* 模拟定时器的数量 * 模拟定时器的数量
*/ */
#define SIMULAT_TIMER_NUM 5 #define SIMULAT_TIMER_NUM 5
typedef struct st_register_ typedef struct st_register_
{ {
uint32_t count; // 定时器计数 uint32_t count; // 定时器计数
uint32_t cmr; // 比较寄存器 uint32_t cmr; // 比较寄存器
struct struct
{ {
uint8_t ten : 1; // 使能标志 uint8_t ten : 1; // 使能标志
uint8_t tov : 1; // 溢出标志 uint8_t tov : 1; // 溢出标志
uint8_t tfc : 1; // 自由运行标志 uint8_t tfc : 1; // 自由运行标志
uint8_t tcf : 1; // 比较标志 uint8_t tcf : 1; // 比较标志
} flag; } flag;
} st_register; } st_register;
typedef enum st_mode_ typedef enum st_mode_
{ {
COMPARE = 0, COMPARE = 0,
NO_COMPARE NO_COMPARE
} st_mode; } st_mode;
/*
* st_init() - 初始化实现模拟定时器所需的pit定时器 void st_base_init(void);
* uint8_t st_init(uint8_t n, st_mode st_m, uint32_t cmr_v);
* 基础定时为1ms void st_close(uint8_t n);
*/ uint8_t st_tcf(uint8_t n);
void st_base_init(void); uint8_t st_tov(uint8_t n);
uint32_t st_count(uint8_t n);
void st_base(void);
/*
* st_init() - 初始化一个给定编号的模拟定时器
* @n: 定时器编号
* @st_m: 定时模式
* @cmr_v: 定时器比较值，在非比较模式可以为任意值
*
* 这个函数返回0表示正常完成了初始化任务，返回~0表示定时器已打开或不存在
*/ #endif /* SIMULAT_TIMER_H */
uint8_t st_init(uint8_t n, st_mode st_m, uint32_t cmr_v);
/*
* st_close() - 关闭一个给定编号的模拟定时器
* @n: 定时器编号
*/
void st_close(uint8_t n);
/*
* st_tcf() - 查询tcf位返回
* @n: 定时器编号
*
* 这个函数在没有过比较值的时候返回0，已过比较值得时候返回1，对于不存在或未打开
*/
uint8_t st_tcf(uint8_t n);
/*
* st_tov() - 查询tov位返回
* @n: 定时器编号
*
* 这个函数在没有溢出时返回0，没有溢出时返回1，对于不存在或未打开
*/
uint8_t st_tov(uint8_t n);
/*
* st_count() - 查询当前模拟定时值
* @n: 定时器编号
*
* 对于不存在或未打开
*/
uint32_t st_count(uint8_t n);
/********************ISR******************/
/*
* st_base() -定时调用以模拟N路定时器
*
* 定时的最小间隔等于这个函数被调用的周期
*/
void st_base(void);
#endif /* SIMULAT_TIMER_H */

85
plan_manage_main/src/app/include/tft.h
View file

@ -1,43 +1,42 @@
/* /*
* tft.h - tft½Ó¿Ú * tft.h - tft½Ó¿Ú
*/ */
#ifndef TFT_H #ifndef TFT_H
#define TFT_H #define TFT_H
typedef struct input_limit_ typedef struct input_limit_
{ {
int16_t max; int16_t max;
int16_t min; int16_t min;
} input_limit; } input_limit;
void tft_init(void); void tft_init(void);
void tft_send_cmd(const char *cmd); void tft_send_cmd(const char *cmd);
void tft_left(void); void tft_left(void);
void tft_right(void); void tft_right(void);
void tft_up(void); void tft_up(void);
void tft_down(void); void tft_down(void);
void tft_ok(void); void tft_ok(void);
void tft_ret(void); void tft_ret(void);
void tft_page_refresh(void); void tft_page_refresh(void);
int16_t *get_value_of_kvp(char *name, uint8_t objn); int16_t *get_value_of_kvp(char *name, uint8_t objn);
input_limit tft_input_limit(char *name); input_limit tft_input_limit(char *name);
//const kv_pair *get_plan_data(uint8_t objn)[][PLAN_DATA_NUM];
#endif /* TFT_H */
#endif /* TFT_H */

89
plan_manage_main/src/app/include/tft_plan_internal.h
View file

@ -1,41 +1,48 @@
/* /*
* tft_handle_internal.h - tft和plan_handle模块共同使用部分的内部声明 * tft_handle_internal.h - tft和plan_handle模块共同使用部分的内部声明
* *
* 这个文件只应包含在tft和plan_handle模块 * 这个文件只应包含在tft和plan_handle模块
*/ */
#include "include/pm_time.h" #include "include/pm_time.h"
/*
typedef struct plan_input_ * plan_input - 表示计划输入的类型
{ *
calendar_info bg_t; */
calendar_info ed_t; typedef struct plan_input_
calendar_info pd_t; {
calendar_info bg_t; // 开始时间
uint8_t x_orient; calendar_info ed_t; // 结束时间
uint8_t y_orient; calendar_info pd_t; // 周期时长
uint8_t lg_r : 1;
uint8_t lg_b : 1; uint8_t x_orient; // x方向值，未使用
uint8_t lg_uvb : 1; uint8_t y_orient; // y方向值，未使用
uint8_t water : 1; uint8_t lg_r : 1; // 红灯
uint8_t sw : 1; uint8_t lg_b : 1; // 蓝灯
uint8_t cnt; uint8_t lg_uvb : 1; // uvb
} plan_input; uint8_t water : 1; // 浇水，未使用
uint8_t sw : 1; // 是否加入计划
typedef struct kv_pair_ uint8_t cnt; // 完成次数
{ } plan_input;
char *key;
int16_t value; /*
int8_t attr; * kv_pair - 表示页面中的元素
} kv_pair; * key为存储元素ID的字符串，value为一个整形值，attr为元素属性
*/
enum { PLAN_DATA_NUM = 19 }; typedef struct kv_pair_
{
extern plan_input plan_in[PLAN_DATA_NUM]; char *key;
int16_t value;
extern kv_pair kvp_obj_set[][PLAN_DATA_NUM]; int8_t attr;
} kv_pair;
enum { PLAN_DATA_NUM = 19, OBJ_NUM = 8 };
void tft_to_plan_input(uint8_t objn);
extern plan_input plan_in[OBJ_NUM];
extern kv_pair kvp_obj_set[][PLAN_DATA_NUM];
void tft_to_plan_input(uint8_t objn);

4
plan_manage_main/src/app/include/water.h
View file

@ -14,11 +14,7 @@
void water_init(void); void water_init(void);
uint16_t get_moisture(void); uint16_t get_moisture(void);
void water_ctr(uint16_t sv_moist); void water_ctr(uint16_t sv_moist);

716
plan_manage_main/src/app/key.c
View file

@ -1,352 +1,364 @@
/* /*
* key.c - 监测并采集按键的输入 * key.c - 监测并采集按键的输入
* *
* 共有四种输入，无键，单击，双击，长击。 * 共有四种输入，无键，单击，双击，长击。
* 每10ms需要采集一次io状态。 * 每10ms需要采集一次io状态。
* 每增减一个按键，需要设置的有: * 每增减一个按键，需要设置的有:
* *
* key_type枚举类型中对应的枚举元素 * key_type枚举类型中对应的枚举元素
* *
* 对应的key_infomation变量 * 对应的key_infomation变量
* *
* key_init()函数中对应的初始化条目 * key_init()函数中对应的初始化条目
* key_detect()函数中对应检测条目 * key_detect()函数中对应检测条目
* get_key_mean()函数中对应获取条目 * get_key_mean()函数中对应获取条目
*/ */
#include <stdint.h> #include <stdint.h>
#include "include.h" #include "include.h"
#include "include/key.h" #include "include/key.h"
#include "include/config.h" #include "include/config.h"
/* /*
* key_state - 表示按键的状态 * key_state - 表示按键的状态
* key_state_0 初始状态，或者表示第一次单击状态 * key_state_0 初始状态，或者表示第一次单击状态
* key_state_1 消抖和确认状态，或表示第二次单击状态 * key_state_1 消抖和确认状态，或表示第二次单击状态
* key_state_2 按键计时状态 * key_state_2 按键计时状态
* key_state_3 按键等待释放状态 * key_state_3 按键等待释放状态
*/ */
typedef enum key_state_ typedef enum key_state_
{ {
key_state_0 = 0, key_state_1, key_state_2, key_state_3 key_state_0 = 0, key_state_1, key_state_2, key_state_3
} key_state; } key_state;
/* /*
* IO状态符号定义 * IO状态符号定义
*/ */
typedef enum state_sign_ typedef enum state_sign_
{ {
INVALID = 0, VALID = 1 INVALID = 0, VALID = 1
} state_sign; } state_sign;
typedef struct key_infomation_ /*
{ * key_infomation - 表示一个按键的信息
key_state state_base; * state_base和time_base在key_read_base函数中使用的状态变量
uint8_t time_base; * state和time在key_read函数中使用的状态变量
* key_m保存当前按键读取的结果
key_state state; * get_state_io变量指向获取按键对应输入io状态的函数
uint8_t time; */
typedef struct key_infomation_
key_mean key_m; {
key_state state_base;
state_sign (*get_state_io)(void); uint8_t time_base;
} key_infomation;
key_state state;
uint8_t time;
state_sign get_state_up_key_io(void) key_mean key_m;
{ return !gpio_get(UP_KEY_PINX) ? VALID : INVALID; }
state_sign (*get_state_io)(void);
state_sign get_state_down_key_io(void) } key_infomation;
{ return !gpio_get(DOWN_KEY_PINX) ? VALID : INVALID; }
state_sign get_state_ok_key_io(void)
{ return !gpio_get(OK_KEY_PINX) ? VALID : INVALID; } /*
* 下边这几个函数定义的是获取按键io状态的函数
state_sign get_state_ret_key_io(void) */
{ return !gpio_get(RET_KEY_PINX) ? VALID : INVALID; } state_sign get_state_up_key_io(void)
{ return !gpio_get(UP_KEY_PINX) ? VALID : INVALID; }
state_sign get_state_ams_key_io(void)
{ return !gpio_get(AMS_KEY_PINX) ? VALID : INVALID; } state_sign get_state_down_key_io(void)
{ return !gpio_get(DOWN_KEY_PINX) ? VALID : INVALID; }
state_sign get_state_wifi_key_io(void)
{ return !gpio_get(WIFI_KEY_PINX) ? VALID : INVALID; } state_sign get_state_ok_key_io(void)
{ return !gpio_get(OK_KEY_PINX) ? VALID : INVALID; }
state_sign get_state_mr_key_io(void)
{ return !gpio_get(MR_KEY_PINX) ? VALID : INVALID; } state_sign get_state_ret_key_io(void)
{ return !gpio_get(RET_KEY_PINX) ? VALID : INVALID; }
state_sign get_state_mb_key_io(void)
{ return !gpio_get(MB_KEY_PINX) ? VALID : INVALID; } state_sign get_state_ams_key_io(void)
{ return !gpio_get(AMS_KEY_PINX) ? VALID : INVALID; }
state_sign get_state_muvb_key_io(void)
{ return !gpio_get(MUVB_KEY_PINX) ? VALID : INVALID; } state_sign get_state_wifi_key_io(void)
{ return !gpio_get(WIFI_KEY_PINX) ? VALID : INVALID; }
static volatile key_infomation state_sign get_state_mr_key_io(void)
up_key_info = { key_state_0, 0, key_state_0, 0, N_KEY, get_state_up_key_io }, { return !gpio_get(MR_KEY_PINX) ? VALID : INVALID; }
down_key_info = { key_state_0, 0, key_state_0, 0, N_KEY, get_state_down_key_io },
ok_key_info = { key_state_0, 0, key_state_0, 0, N_KEY, get_state_ok_key_io }, state_sign get_state_mb_key_io(void)
ret_key_info = { key_state_0, 0, key_state_0, 0, N_KEY, get_state_ret_key_io }, { return !gpio_get(MB_KEY_PINX) ? VALID : INVALID; }
ams_key_info = { key_state_0, 0, key_state_0, 0, N_KEY, get_state_ams_key_io },
wifi_key_info = { key_state_0, 0, key_state_0, 0, N_KEY, get_state_wifi_key_io }, state_sign get_state_muvb_key_io(void)
mr_key_info = { key_state_0, 0, key_state_0, 0, N_KEY, get_state_mr_key_io }, { return !gpio_get(MUVB_KEY_PINX) ? VALID : INVALID; }
mb_key_info = { key_state_0, 0, key_state_0, 0, N_KEY, get_state_mb_key_io },
muvb_key_info = { key_state_0, 0, key_state_0, 0, N_KEY, get_state_muvb_key_io };
// 定义按键变量并初始化
static volatile key_infomation
up_key_info = { key_state_0, 0, key_state_0, 0, N_KEY, get_state_up_key_io },
/* down_key_info = { key_state_0, 0, key_state_0, 0, N_KEY, get_state_down_key_io },
* key_init() - 按键模块初始化 ok_key_info = { key_state_0, 0, key_state_0, 0, N_KEY, get_state_ok_key_io },
* ret_key_info = { key_state_0, 0, key_state_0, 0, N_KEY, get_state_ret_key_io },
*/ ams_key_info = { key_state_0, 0, key_state_0, 0, N_KEY, get_state_ams_key_io },
void key_init(void) wifi_key_info = { key_state_0, 0, key_state_0, 0, N_KEY, get_state_wifi_key_io },
{ mr_key_info = { key_state_0, 0, key_state_0, 0, N_KEY, get_state_mr_key_io },
gpio_Interrupt_init(UP_KEY_PINX, GPI_UP_PF, GPI_DISAB); mb_key_info = { key_state_0, 0, key_state_0, 0, N_KEY, get_state_mb_key_io },
gpio_Interrupt_init(DOWN_KEY_PINX, GPI_UP_PF, GPI_DISAB); muvb_key_info = { key_state_0, 0, key_state_0, 0, N_KEY, get_state_muvb_key_io };
gpio_Interrupt_init(OK_KEY_PINX, GPI_UP_PF, GPI_DISAB);
gpio_Interrupt_init(RET_KEY_PINX, GPI_UP_PF, GPI_DISAB);
gpio_Interrupt_init(AMS_KEY_PINX, GPI_UP_PF, GPI_DISAB);
gpio_Interrupt_init(WIFI_KEY_PINX, GPI_UP_PF, GPI_DISAB); /**
gpio_Interrupt_init(MR_KEY_PINX, GPI_UP_PF, GPI_DISAB); * key_init() - 按键模块初始化
gpio_Interrupt_init(MB_KEY_PINX, GPI_UP_PF, GPI_DISAB); *
gpio_Interrupt_init(MUVB_KEY_PINX, GPI_UP_PF, GPI_DISAB); */
void key_init(void)
{
/* gpio_Interrupt_init(UP_KEY_PINX, GPI_UP_PF, GPI_DISAB);
* 初始化定时器为10ms定时中断，用于按键检测的定时执行 gpio_Interrupt_init(DOWN_KEY_PINX, GPI_UP_PF, GPI_DISAB);
*/ gpio_Interrupt_init(OK_KEY_PINX, GPI_UP_PF, GPI_DISAB);
gpio_Interrupt_init(RET_KEY_PINX, GPI_UP_PF, GPI_DISAB);
gpio_Interrupt_init(AMS_KEY_PINX, GPI_UP_PF, GPI_DISAB);
return; gpio_Interrupt_init(WIFI_KEY_PINX, GPI_UP_PF, GPI_DISAB);
} gpio_Interrupt_init(MR_KEY_PINX, GPI_UP_PF, GPI_DISAB);
gpio_Interrupt_init(MB_KEY_PINX, GPI_UP_PF, GPI_DISAB);
gpio_Interrupt_init(MUVB_KEY_PINX, GPI_UP_PF, GPI_DISAB);
/*
* key_read_base - 按键基础读取函数， return;
* @key_info: 要检测按键的所需信息,必须在是全局变量区中存储的 }
*
* 这个函数返回 N_KEY,S_KEY,L_KEY三种情况
*/ /**
key_mean key_read_base(volatile key_infomation *key_info) * key_read_base - 按键基础读取函数，
{ * @key_info: 要检测按键的所需信息,必须在是全局变量区中存储的
state_sign key_state_io; *
key_mean key_m = N_KEY; * 这个函数返回 N_KEY,S_KEY,L_KEY三种情况
*/
key_state_io = (*((*key_info).get_state_io))(); // 获取io状态 key_mean key_read_base(volatile key_infomation *key_info)
switch((*key_info).state_base) {
{ state_sign key_state_io;
case key_state_0: key_mean key_m = N_KEY;
if (key_state_io == VALID)
{ // 获取io状态
(*key_info).state_base = key_state_1; // 按键按下后首先进入消抖和按键确 key_state_io = (*(key_info->get_state_io))();
// 认状态 switch(key_info->state_base)
} {
break; case key_state_0:
case key_state_1: if (key_state_io == VALID)
if (key_state_io == VALID) {
{ // 按键按下后首先进入消抖和按键确认状态
(*key_info).time_base = 0; key_info->state_base = key_state_1;
(*key_info).state_base = key_state_2; // 按键如果仍然按下，则消抖完成， }
// 状态转换,此时返回无按键事件 break;
} case key_state_1:
else if (key_state_io == VALID)
{ {
(*key_info).state_base = key_state_0; // 按键如果仍然按下，则消抖完成
} // 进行状态转换,并且返回无按键事件
break; key_info->time_base = 0;
case key_state_2: key_info->state_base = key_state_2;
if (key_state_io == INVALID) }
{ else
key_m = S_KEY; // 此时按键释放说明为一次短操作 {
(*key_info).state_base = key_state_0; key_info->state_base = key_state_0;
} }
else if (++(*key_info).time_base > 100) // 继续按下，计时加10ms，即本函 break;
// 数调用周期 case key_state_2:
{ if (key_state_io == INVALID)
key_m = L_KEY; // 按下时间大于1s，返回 长按键 {
(*key_info).state_base = key_state_3; // 转换为等待按键释放状态 // 此时按键释放说明为一次短操作
} key_m = S_KEY;
break; key_info->state_base = key_state_0;
case key_state_3: }
if (key_state_io == INVALID) // 继续按下，计时加10ms，即本函数调用周期
{ else if (++key_info->time_base > 100)
(*key_info).state_base = key_state_0; // 按键此时已释放，转换为初始状态 {
} // 按下时间大于1s，返回长按键，并且转换为等待按键释放状态
break; key_m = L_KEY;
default: key_info->state_base = key_state_3;
break; }
} break;
return key_m; case key_state_3:
} if (key_state_io == INVALID)
{
/* // 按键此时已释放，转换为初始状态
* key_read - 按键读取函数 key_info->state_base = key_state_0;
* @key_info: 要检测的按键所需的信息，必须是在全局变量区中存储的 }
* break;
* 这个函数会返回N_KEY,S_KEY,D_KEY，L_KEY四情况 default:
*/ break;
key_mean key_read(volatile key_infomation *key_info) }
{ return key_m;
key_mean key_m = N_KEY, }
key_m_temp;
/**
key_m_temp = key_read_base(key_info); * key_read - 按键读取函数
switch((*key_info).state) * @key_info: 要检测的按键所需的信息，必须是在全局变量区中存储的
{ *
case key_state_0: * 这个函数会返回N_KEY,S_KEY,D_KEY，L_KEY四情况
if (key_m_temp == S_KEY) */
{ key_mean key_read(volatile key_infomation *key_info)
(*key_info).time = 0; // 第一次单击状态，仍然返回无键，到下个周期 {
// 判断是否出现双击 key_mean key_m = N_KEY,
(*key_info).state = key_state_1; key_m_temp;
}
else key_m_temp = key_read_base(key_info);
{ switch(key_info->state)
key_m = key_m_temp; // 对于非单击，返回原事件 {
} case key_state_0:
break; if (key_m_temp == S_KEY)
case key_state_1: {
if (key_m_temp == S_KEY) // 又一次单击，间隔 < 300ms // 第一次单击状态，仍然返回无键，到下个周期判断是否出现双击
{ key_info->time = 0;
key_m = D_KEY; key_info->state = key_state_1;
(*key_info).state = key_state_0; }
} else
else {
{ // 对于非单击，返回原事件
if (++(*key_info).time > 30) key_m = key_m_temp;
{ }
key_m = S_KEY; // 300ms内没有再出现单击事件，则返回上一次单 break;
// 击事件 case key_state_1:
(*key_info).state = key_state_0; // 又一次单击，间隔 < 300ms
} if (key_m_temp == S_KEY)
} {
break; key_m = D_KEY;
default: key_info->state = key_state_0;
break; }
} else
return key_m; {
} if (++key_info->time > 30)
{
// 300ms内没有再出现单击事件，则返回上一次单击事件
/* key_m = S_KEY;
* key_detect() - 检测按键 key_info->state = key_state_0;
* }
* 这个函数仅在N_KEY状态时记录按键信息，N_KEY是在应用程序获取按键信息的时候同时被设 }
* 置的，这样做的目的是保证采集到的按键一定会被执行 break;
* 要求每隔10ms调用一次 default:
*/ break;
void key_detect(void) }
{ return key_m;
key_mean key_m; }
if ((key_m = key_read(&up_key_info)) != N_KEY)
{ /**
up_key_info.key_m = key_m; * key_detect() - 检测按键
} *
if ((key_m = key_read(&down_key_info)) != N_KEY) * 这个函数仅在N_KEY状态时记录按键信息，N_KEY是在应用程序获取按键信息的时候同时
{ * 被设置的，这样做的目的是保证采集到的按键一定会被执行
down_key_info.key_m = key_m; * 要求每隔10ms调用一次
} */
if ((key_m = key_read(&ok_key_info)) != N_KEY) void key_detect(void)
{ {
ok_key_info.key_m = key_m; key_mean key_m;
}
if ((key_m = key_read(&ret_key_info)) != N_KEY) if ((key_m = key_read(&up_key_info)) != N_KEY)
{ {
ret_key_info.key_m = key_m; up_key_info.key_m = key_m;
} }
if ((key_m = key_read(&ams_key_info)) != N_KEY) if ((key_m = key_read(&down_key_info)) != N_KEY)
{ {
ams_key_info.key_m = key_m; down_key_info.key_m = key_m;
} }
if ((key_m = key_read(&wifi_key_info)) != N_KEY) if ((key_m = key_read(&ok_key_info)) != N_KEY)
{ {
wifi_key_info.key_m = key_m; ok_key_info.key_m = key_m;
} }
if ((key_m = key_read(&mr_key_info)) != N_KEY) if ((key_m = key_read(&ret_key_info)) != N_KEY)
{ {
mr_key_info.key_m = key_m; ret_key_info.key_m = key_m;
} }
if ((key_m = key_read(&mb_key_info)) != N_KEY) if ((key_m = key_read(&ams_key_info)) != N_KEY)
{ {
mb_key_info.key_m = key_m; ams_key_info.key_m = key_m;
} }
if ((key_m = key_read(&muvb_key_info)) != N_KEY) if ((key_m = key_read(&wifi_key_info)) != N_KEY)
{ {
muvb_key_info.key_m = key_m; wifi_key_info.key_m = key_m;
} }
return; if ((key_m = key_read(&mr_key_info)) != N_KEY)
} {
mr_key_info.key_m = key_m;
}
/* if ((key_m = key_read(&mb_key_info)) != N_KEY)
* get_key_mean() - 得到指定的按键信息 {
* mb_key_info.key_m = key_m;
* 这个函数中在取得信息后会将对应按键重新标记为N_KEY }
*/ if ((key_m = key_read(&muvb_key_info)) != N_KEY)
key_mean get_key_mean(key_type key_t) {
{ muvb_key_info.key_m = key_m;
key_mean key_m; }
return;
switch (key_t) }
{
case UP_KEY:
key_m = up_key_info.key_m; /**
up_key_info.key_m = N_KEY; * get_key_mean() - 得到指定的按键信息
break; *
case DOWN_KEY: * 这个函数中在取得信息后会将对应按键重新标记为N_KEY
key_m = down_key_info.key_m; */
down_key_info.key_m = N_KEY; key_mean get_key_mean(key_type key_t)
break; {
case OK_KEY: key_mean key_m;
key_m = ok_key_info.key_m;
ok_key_info.key_m = N_KEY; switch (key_t)
break; {
case RET_KEY: case UP_KEY:
key_m = ret_key_info.key_m; key_m = up_key_info.key_m;
ret_key_info.key_m = N_KEY; up_key_info.key_m = N_KEY;
break; break;
case AMS_KEY: case DOWN_KEY:
key_m = ams_key_info.key_m; key_m = down_key_info.key_m;
ams_key_info.key_m = N_KEY; down_key_info.key_m = N_KEY;
break; break;
case WIFI_KEY: case OK_KEY:
key_m = wifi_key_info.key_m; key_m = ok_key_info.key_m;
wifi_key_info.key_m = N_KEY; ok_key_info.key_m = N_KEY;
break; break;
case MR_KEY: case RET_KEY:
key_m = mr_key_info.key_m; key_m = ret_key_info.key_m;
mr_key_info.key_m = N_KEY; ret_key_info.key_m = N_KEY;
break; break;
case MB_KEY: case AMS_KEY:
key_m = mb_key_info.key_m; key_m = ams_key_info.key_m;
mb_key_info.key_m = N_KEY; ams_key_info.key_m = N_KEY;
break; break;
case MUVB_KEY: case WIFI_KEY:
key_m = muvb_key_info.key_m; key_m = wifi_key_info.key_m;
muvb_key_info.key_m = N_KEY; wifi_key_info.key_m = N_KEY;
break; break;
default: case MR_KEY:
break; key_m = mr_key_info.key_m;
} mr_key_info.key_m = N_KEY;
return key_m; break;
} case MB_KEY:
key_m = mb_key_info.key_m;
mb_key_info.key_m = N_KEY;
void clear_key_m(void) break;
{ case MUVB_KEY:
down_key_info.key_m = N_KEY; key_m = muvb_key_info.key_m;
up_key_info.key_m = N_KEY; muvb_key_info.key_m = N_KEY;
ok_key_info.key_m = N_KEY; break;
ret_key_info.key_m = N_KEY; default:
ams_key_info.key_m = N_KEY; break;
wifi_key_info.key_m = N_KEY; }
mr_key_info.key_m = N_KEY; return key_m;
mb_key_info.key_m = N_KEY; }
muvb_key_info.key_m = N_KEY;
}
void clear_key_m(void)
{
down_key_info.key_m = N_KEY;
up_key_info.key_m = N_KEY;
ok_key_info.key_m = N_KEY;
ret_key_info.key_m = N_KEY;
ams_key_info.key_m = N_KEY;
wifi_key_info.key_m = N_KEY;
mr_key_info.key_m = N_KEY;
mb_key_info.key_m = N_KEY;
muvb_key_info.key_m = N_KEY;
}

192
plan_manage_main/src/app/knob.c
View file

@ -1,95 +1,97 @@
/* /*
* knob.c - 提供旋钮输入的接口函数 * knob.c - 提供旋钮输入的接口函数
* *
* 使用的是一个数字旋钮，利用计数来采集输入 * 使用的是一个数字旋钮，利用计数来采集输入
*/ */
#include <stdint.h> #include <stdint.h>
#include "include.h" #include "include.h"
#include "arm_cm0.h"
#include "vectors.h"
#include "include/knob.h"
#include "include/config.h" #include "include/config.h"
#include "include/knob.h"
static volatile int32_t knob_val;
static volatile int32_t knob_val;
/*
* knob_init() - 为旋钮输入而执行的初始化 /*
* * knob_init() - 为旋钮输入而执行的初始化
* 旋钮的检测初始化后默认是禁止的 *
*/ * 旋钮的检测初始化后默认是禁止的
void knob_init(void) */
{ void knob_init(void)
gpio_Interrupt_init(KNOB_A_PINX, GPI_UP_PF, GPI_INP_EITH); {
gpio_Interrupt_init(KNOB_B_PINX, GPI_UP_PF, GPI_DISAB); gpio_Interrupt_init(KNOB_A_PINX, GPI_UP_PF, GPI_INP_EITH);
// gpio_Interrupt_init(KNOB_KEY_PINX, GPI_UP_PF, GPI_INP_EITH); gpio_Interrupt_init(KNOB_B_PINX, GPI_UP_PF, GPI_DISAB);
disable_irq(PortD_irq_no); // gpio_Interrupt_init(KNOB_KEY_PINX, GPI_UP_PF, GPI_INP_EITH);
disable_irq(PortD_irq_no);
}
}
/*
* knob_enable() - 使能旋钮脉冲检测 /*
*/ * knob_enable() - 使能旋钮脉冲检测
void knob_enable(void) */
{ void knob_enable(void)
enable_irq(PortD_irq_no); {
return; enable_irq(PortD_irq_no);
} return;
}
/*
* knob_disable() - 禁止旋钮脉冲检测 /*
*/ * knob_disable() - 禁止旋钮脉冲检测
void knob_disable(void) */
{ void knob_disable(void)
disable_irq(PortA_irq_no); {
return; disable_irq(PortD_irq_no);
} return;
}
/*
* knob_clear() - 清除旋钮值 /*
*/ * knob_clear() - 清除旋钮值
void knob_clear(void) */
{ void knob_clear(void)
knob_val = 0; {
return; knob_val = 0;
} return;
}
/*
* get_knob_val() - 返回旋钮值 /*
*/ * get_knob_val() - 返回旋钮值
int32_t get_knob_val(void) */
{ int32_t get_knob_val(void)
return knob_val; {
} return knob_val;
}
/*
* knob_detect() - 旋钮检测 /*
* * knob_detect() - 旋钮检测
* 这个函数需要在旋钮编码器的A相输出发生沿跳变时调用，即上下沿中断时 *
*/ * 这个函数需要在旋钮编码器的A相输出发生沿跳变时调用，即上下沿中断时
void knob_detect(void) */
{ void knob_detect(void)
uint8_t knob_A, knob_B; {
uint8_t knob_A, knob_B;
knob_A = gpio_get(KNOB_A_PINX);
knob_B = gpio_get(KNOB_B_PINX); knob_A = gpio_get(KNOB_A_PINX);
if ((knob_A == 0 && knob_B == 1) || (knob_A == 1 && knob_B == 0)) knob_B = gpio_get(KNOB_B_PINX);
{ if ((knob_A == 0 && knob_B == 1) || (knob_A == 1 && knob_B == 0))
knob_val++; {
} knob_val++;
else // 即if ((knob_A == 0 && knob_B == 0) || (knob_A == 1 && knob_B == 1)) }
{ // 即if ((knob_A == 0 && knob_B == 0) || (knob_A == 1 && knob_B == 1))
knob_val--; else
} {
return; knob_val--;
} }
return;
}

6
plan_manage_main/src/app/main.c
View file

@ -24,8 +24,10 @@ void main(void)
enter_critical(); enter_critical();
pm_init(); pm_init();
exit_critical(); exit_critical();
/*
st_init(0, COMPARE, 10); // 作为按键扫描函数的定时使用，在simulat_timer.c的底层中使用 * 作为按键扫描函数的定时使用，在simulat_timer.c的底层中使用
*/
st_init(0, COMPARE, 10);
st_init(1, COMPARE, 100); st_init(1, COMPARE, 100);
#ifdef PM_DEBUG #ifdef PM_DEBUG

240
plan_manage_main/src/app/orient.c
View file

@ -1,120 +1,120 @@
/* /*
* orient.c - 关于光照方向控制的模块 * orient.c - 关于光照方向控制的模块
* *
* 所有如上，所有如下 * 所有如上，所有如下
*/ */
#include "uart.h" #include "uart.h"
#include "include/orient.h" #include "include/orient.h"
#include "include/config.h" #include "include/config.h"
void orient_init(void) void orient_init(void)
{ {
uart_init(ORIENT_UARTX, 2400); uart_init(ORIENT_UARTX, 2400);
gpio_init(RE_DE_PINX, 1, 1); gpio_init(RE_DE_PINX, 1, 1);
orient_setmode(0, MODE_MANUL); orient_setmode(0, MODE_MANUL);
orient_setmode(1, MODE_MANUL); orient_setmode(1, MODE_MANUL);
return; return;
} }
/* /*
* orient_setspeed() - 设置方向控制的速度以及角度 * orient_setspeed() - 设置方向控制的速度以及角度
* *
* @addr: 地址码 * @addr: 地址码
* @ori: 方向 * @ori: 方向
* @spd: 表示速度，范围在0~100 * @spd: 表示速度，范围在0~100
*/ */
void orient_setspeed(uint8_t addr, orient ori, uint8_t spd) void orient_setspeed(uint8_t addr, orient ori, uint8_t spd)
{ {
uint8_t cmd[7] = { 0xff, addr, 0x00, 0x00, 0x00, 0x00, 0x00 }; uint8_t cmd[7] = { 0xff, addr, 0x00, 0x00, 0x00, 0x00, 0x00 };
switch (ori) switch (ori)
{ {
case ORIENT_UP: case ORIENT_UP:
cmd[3] = 0x08; cmd[3] = 0x08;
break; break;
case ORIENT_DOWN: case ORIENT_DOWN:
cmd[3] = 0x10; cmd[3] = 0x10;
break; break;
case ORIENT_LEFT: case ORIENT_LEFT:
cmd[3] = 0x04; cmd[3] = 0x04;
break; break;
case ORIENT_RIGHT: case ORIENT_RIGHT:
cmd[3] = 0x02; cmd[3] = 0x02;
default: default:
break; break;
} }
if (spd > 100) if (spd > 100)
{ {
spd = 100; spd = 100;
} }
cmd[4] = 0x3f * spd / 100; cmd[4] = (uint16_t)0x3f * spd / 100;
cmd[6] = cmd[1] + cmd[2] + cmd[3] + cmd[4] + cmd[5]; cmd[6] = cmd[1] + cmd[2] + cmd[3] + cmd[4] + cmd[5];
uart_sendN(ORIENT_UARTX, cmd, 7); uart_sendN(ORIENT_UARTX, cmd, 7);
return; return;
} }
/* /*
* orient_presetop() - 设置预置点 * orient_presetop() - 设置预置点
* *
* @addr: 地址码 * @addr: 地址码
* @op: 对预置点的操作 * @op: 对预置点的操作
* @npre: 预置点编号 * @npre: 预置点编号
*/ */
void orient_presetop(uint8_t addr, preset_op op, uint8_t npre) void orient_presetop(uint8_t addr, preset_op op, uint8_t npre)
{ {
uint8_t cmd[7] = { 0xff, addr, 0x00, 0x00, 0x00, npre, 0x00 }; uint8_t cmd[7] = { 0xff, addr, 0x00, 0x00, 0x00, npre, 0x00 };
switch (op) switch (op)
{ {
case PRESET_SET: case PRESET_SET:
cmd[3] = 0x03; cmd[3] = 0x03;
break; break;
case PRESET_CALL: case PRESET_CALL:
cmd[3] = 0x07; cmd[3] = 0x07;
break; break;
case PRESET_CLEAR: case PRESET_CLEAR:
cmd[3] = 0x05; cmd[3] = 0x05;
break; break;
default: default:
break; break;
} }
cmd[6] = cmd[1] + cmd[2] + cmd[3] + cmd[4] + cmd[5]; cmd[6] = cmd[1] + cmd[2] + cmd[3] + cmd[4] + cmd[5];
uart_sendN(ORIENT_UARTX, cmd, 7); uart_sendN(ORIENT_UARTX, cmd, 7);
return; return;
} }
/* /*
* orient_setmode() - 设置云台模式 * orient_setmode() - 设置云台模式
* *
* @addr: 地址码 * @addr: 地址码
* @mod: 模式标志 * @mod: 模式标志
*/ */
void orient_setmode(uint8_t addr, orient_mode mod) void orient_setmode(uint8_t addr, orient_mode mod)
{ {
uint8_t cmd[7] = { 0xff, addr, 0x00, 0x00, 0x00, 0x00, 0x00 }; uint8_t cmd[7] = { 0xff, addr, 0x00, 0x00, 0x00, 0x00, 0x00 };
switch (mod) switch (mod)
{ {
case MODE_AUTO: case MODE_AUTO:
cmd[2] = 0x90; cmd[2] = 0x90;
break; break;
case MODE_MANUL: case MODE_MANUL:
cmd[2] = 0x00; cmd[2] = 0x00;
break; break;
default: default:
break; break;
} }
cmd[6] = cmd[1] + cmd[2] + cmd[3] + cmd[4] + cmd[5]; cmd[6] = cmd[1] + cmd[2] + cmd[3] + cmd[4] + cmd[5];
uart_sendN(ORIENT_UARTX, cmd, 7); uart_sendN(ORIENT_UARTX, cmd, 7);
return; return;
} }

1251
plan_manage_main/src/app/plan_handle.c
View file

File diff suppressed because it is too large Load diff

335
plan_manage_main/src/app/pm_flash.c
View file

@ -1,164 +1,171 @@
/* /*
* pm_flash.c - flash读写模块 * pm_flash.c - flash读写模块
*/ */
#include "SSD_FTFx.h" #include "SSD_FTFx.h"
#include "pm_flash_cfg.h" #include "pm_flash_cfg.h"
#define USED_SECTOR_NUM 0x01U #define USED_SECTOR_NUM 0x01U
FLASH_SSD_CONFIG flashSSDConfig = FLASH_SSD_CONFIG flashSSDConfig =
{ {
FTFx_REG_BASE, /* FTFx control register base */ FTFx_REG_BASE, /* FTFx control register base */
PFLASH_BLOCK_BASE, /* base address of PFlash block */ PFLASH_BLOCK_BASE, /* base address of PFlash block */
PBLOCK_SIZE, /* size of PFlash block */ PBLOCK_SIZE, /* size of PFlash block */
DEFLASH_BLOCK_BASE, /* base address of DFlash block */ DEFLASH_BLOCK_BASE, /* base address of DFlash block */
0x0U, /* size of DFlash block */ 0x0U, /* size of DFlash block */
EERAM_BLOCK_BASE, /* base address of EERAM block */ EERAM_BLOCK_BASE, /* base address of EERAM block */
0x0U, /* size of EEE block */ 0x0U, /* size of EEE block */
DEBUGENABLE, /* background debug mode enable bit */ DEBUGENABLE, /* background debug mode enable bit */
NULL_CALLBACK /* pointer to callback function */ NULL_CALLBACK /* pointer to callback function */
}; };
#define LAUNCH_CMD_SIZE 0x80U #define LAUNCH_CMD_SIZE 0x80U
pFLASHCOMMANDSEQUENCE g_FlashLaunchCommand = (pFLASHCOMMANDSEQUENCE)0xFFFFFFFF; pFLASHCOMMANDSEQUENCE g_FlashLaunchCommand = (pFLASHCOMMANDSEQUENCE)0xFFFFFFFF;
uint16_t __ram_func[LAUNCH_CMD_SIZE/2]; /* array to copy __Launch_Command func to RAM */ /* array to copy __Launch_Command func to RAM */
uint16_t __ram_func[LAUNCH_CMD_SIZE/2];
void pm_flash_init(void)
{ void pm_flash_init(void)
uint32_t ret; {
uint32_t ret;
g_FlashLaunchCommand =
(pFLASHCOMMANDSEQUENCE)RelocateFunction((uint32_t)__ram_func , g_FlashLaunchCommand =
LAUNCH_CMD_SIZE ,(uint32_t)FlashCommandSequence); (pFLASHCOMMANDSEQUENCE)RelocateFunction((uint32_t)__ram_func ,
ret = FlashInit(&flashSSDConfig); LAUNCH_CMD_SIZE ,(uint32_t)FlashCommandSequence);
if (FTFx_OK != ret) ret = FlashInit(&flashSSDConfig);
{ if (FTFx_OK != ret)
ErrorTrap(ret); {
} ErrorTrap(ret);
return; }
} return;
}
/*
* flash_write() - 将数据写入flash /*
* @saddr: 要写入的数据的起始地址 * flash_write() - 将数据写入flash
* @size: 写入数据的字节数，字节数必须要以4对齐！！！ * @saddr: 要写入的数据的起始地址
* * @size: 写入数据的字节数，字节数必须要以4对齐！！！
* 这个函数的执行过程包括擦除和写入，默认的写入范围为flash的最后一个扇区，大小为 *
* 1KB，如果要改变大小，改参数就可以了，注意不要覆盖了code，具体可看map文件。 * 这个函数的执行过程包括擦除和写入，默认的写入范围为flash的最后一个扇区，大小为
* 擦除是一次性擦除全部选择的扇区范围，所以在写入的时候要注意保存先前写入的数据 * 1KB，如果要改变大小，改参数就可以了，注意不要覆盖了code，具体可看map文件。
* flash读取函数的起始地址等于flash写入函数的写入起始地址 * 擦除是一次性擦除全部选择的扇区范围，所以在写入的时候要注意保存先前写入的数据
*/ * flash读取函数的起始地址等于flash写入函数的写入起始地址
void flash_write(uint8_t *saddr, uint16_t nbyte) */
{ void flash_write(uint8_t *saddr, uint16_t nbyte)
uint32_t ret; {
uint32_t dest; uint32_t ret;
uint32_t size; uint32_t dest;
uint16_t number; uint32_t size;
uint32_t temp; uint16_t number;
uint32_t temp;
/*
* 擦除扇区 /*
*/ * 擦除扇区
dest = flashSSDConfig.PFlashBlockBase + BYTE2WORD(flashSSDConfig.PFlashBlockSize */
- USED_SECTOR_NUM * FTFx_PSECTOR_SIZE); dest = flashSSDConfig.PFlashBlockBase + BYTE2WORD(
while ((dest + BYTE2WORD(FTFx_PSECTOR_SIZE)) <= (flashSSDConfig.PFlashBlockBase flashSSDConfig.PFlashBlockSize
+ BYTE2WORD(flashSSDConfig.PFlashBlockSize))) - USED_SECTOR_NUM * FTFx_PSECTOR_SIZE);
{ while ((dest + BYTE2WORD(FTFx_PSECTOR_SIZE)) <=
size = FTFx_PSECTOR_SIZE; (flashSSDConfig.PFlashBlockBase
ret = FlashEraseSector(&flashSSDConfig, dest, size, g_FlashLaunchCommand); + BYTE2WORD(flashSSDConfig.PFlashBlockSize)))
if (FTFx_OK != ret) {
{ size = FTFx_PSECTOR_SIZE;
ErrorTrap(ret); ret = FlashEraseSector(&flashSSDConfig, dest, size,
} g_FlashLaunchCommand);
if (FTFx_OK != ret)
/* 检验 */ {
number = FTFx_PSECTOR_SIZE / PRD1SEC_ALIGN_SIZE; ErrorTrap(ret);
for(uint8_t i = 0x0U; i < 0x2U; i++) }
{
ret = FlashVerifySection(&flashSSDConfig, dest, number, i, g_FlashLaunchCommand); /* 检验 */
if (FTFx_OK != ret) number = FTFx_PSECTOR_SIZE / PRD1SEC_ALIGN_SIZE;
{ for(uint8_t i = 0x0U; i < 0x2U; i++)
ErrorTrap(ret); {
} ret = FlashVerifySection(&flashSSDConfig, dest, number, i,
} g_FlashLaunchCommand);
dest += BYTE2WORD(size); if (FTFx_OK != ret)
} {
ErrorTrap(ret);
/* }
* 写入数据 }
*/ dest += BYTE2WORD(size);
dest = flashSSDConfig.PFlashBlockBase + BYTE2WORD(flashSSDConfig.PFlashBlockSize }
- (uint32_t)(USED_SECTOR_NUM * FTFx_PSECTOR_SIZE));
/*
if ((dest + BYTE2WORD(size)) <= (flashSSDConfig.PFlashBlockBase * 写入数据
+ BYTE2WORD(flashSSDConfig.PFlashBlockSize))) */
{ dest = flashSSDConfig.PFlashBlockBase + BYTE2WORD(
ret = FlashProgram(&flashSSDConfig, dest, nbyte, \ flashSSDConfig.PFlashBlockSize
saddr, g_FlashLaunchCommand); - (uint32_t)(USED_SECTOR_NUM * FTFx_PSECTOR_SIZE));
if (FTFx_OK != ret)
{ if ((dest + BYTE2WORD(size)) <= (flashSSDConfig.PFlashBlockBase
ErrorTrap(ret); + BYTE2WORD(flashSSDConfig.PFlashBlockSize)))
} {
ret = FlashProgram(&flashSSDConfig, dest, nbyte, \
/* 校验和检验 */ saddr, g_FlashLaunchCommand);
uint32_t sum = temp = 0x0U; if (FTFx_OK != ret)
for (uint16_t i = 0x0U; i < nbyte; i++) {
{ ErrorTrap(ret);
temp += saddr[i]; }
}
ret = FlashCheckSum(&flashSSDConfig, dest, nbyte, &sum); /* 校验和检验 */
if ((FTFx_OK != ret) || (temp != sum)) uint32_t sum = temp = 0x0U;
{ for (uint16_t i = 0x0U; i < nbyte; i++)
ErrorTrap(ret); {
} temp += saddr[i];
}
/* 正确测试 */ ret = FlashCheckSum(&flashSSDConfig, dest, nbyte, &sum);
uint32_t FailAddr; if ((FTFx_OK != ret) || (temp != sum))
for (uint8_t i = 0x1U; i < 0x3U; i ++) {
{ ErrorTrap(ret);
ret = FlashProgramCheck(&flashSSDConfig, dest, nbyte, saddr, \ }
&FailAddr, i, g_FlashLaunchCommand);
if (FTFx_OK != ret) /* 正确测试 */
{ uint32_t FailAddr;
ErrorTrap(ret); for (uint8_t i = 0x1U; i < 0x3U; i ++)
} {
} ret = FlashProgramCheck(&flashSSDConfig, dest, nbyte, saddr, \
} &FailAddr, i, g_FlashLaunchCommand);
return; if (FTFx_OK != ret)
} {
ErrorTrap(ret);
/* }
* flash_read() - 读取flash中写入的数据 }
* @daddr: 读取数据要保存的地址 }
* @nbyte: 要读取的字节数 return;
* }
* flash读取函数的起始地址等于flash写入函数的写入起始地址
*/ /*
void flash_read(uint8_t *daddr, uint16_t nbyte) * flash_read() - 读取flash中写入的数据
{ * @daddr: 读取数据要保存的地址
uint8_t *saddr = (uint8_t *)(flashSSDConfig.PFlashBlockBase + BYTE2WORD(flashSSDConfig.PFlashBlockSize * @nbyte: 要读取的字节数
- (uint32_t)(USED_SECTOR_NUM * FTFx_PSECTOR_SIZE))); *
* flash读取函数的起始地址等于flash写入函数的写入起始地址
for (uint16_t i = 0; i < nbyte; i++) */
{ void flash_read(uint8_t *daddr, uint16_t nbyte)
daddr[i] = saddr[i]; {
} uint8_t *saddr = (uint8_t *)(flashSSDConfig.PFlashBlockBase
return; + BYTE2WORD(flashSSDConfig.PFlashBlockSize
} - (uint32_t)(USED_SECTOR_NUM * FTFx_PSECTOR_SIZE)));
/* for (uint16_t i = 0; i < nbyte; i++)
* ErrorTrap() - flash操作错误处理 {
*/ daddr[i] = saddr[i];
void ErrorTrap(uint32_t ret) }
{ return;
while (1) }
{
printf("flash操作错误，返回码为 %d\n", ret); /*
} * ErrorTrap() - flash操作错误处理
return; */
} void ErrorTrap(uint32_t ret)
{
while (1)
{
printf("flash操作错误，返回码为 %d\n", ret);
}
return;
}

720
plan_manage_main/src/app/pm_time.c
View file

@ -1,326 +1,394 @@
/* /*
* pm_time.c - 时间处理 * pm_time.c - 时间处理
*/ */
#include "gpio.h" #include "gpio.h"
#include "include/pm_time.h" #include "include/pm_time.h"
#include "include/config.h" #include "include/config.h"
// 被维护的系统时间
static calendar_info system_time; static calendar_info system_time;
#define DAY_IN_YEAR(nyear) (is_leapyear(nyear) ? 366 : 365) #define DAY_IN_YEAR(nyear) (is_leapyear(nyear) ? 366 : 365)
static const uint8_t day_leap[] = { static const uint8_t day_leap[] = {
0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
}; };
static const uint8_t day_noleap[] = { static const uint8_t day_noleap[] = {
0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
}; };
static void ds1302_byte_write(uint8_t data); /*
static uint8_t ds1302_byte_read(void); * 静态函数声明
static uint8_t ds1302_single_read(uint8_t addr); */
static uint8_t ds1302_single_read(uint8_t addr); static void ds1302_byte_write(uint8_t data);
static int16_t ymd_to_wday(int16_t year, int16_t month, int16_t mday); static uint8_t ds1302_byte_read(void);
static uint8_t ds1302_single_read(uint8_t addr);
void ds1302_single_write(uint8_t addr, uint8_t data);
static int16_t ymd_to_wday(int16_t year, int16_t month, int16_t mday);
/**
uint8_t is_leapyear(uint16_t year) * ds1302_init() - ds1302的初始化
{ *
return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0; * 包括io的初始化以及当ds1302掉电时对其时间值设置初始值
} */
void ds1302_init(void)
uint8_t get_month_days(uint16_t year, uint8_t month) {
{ //gpio_Interrupt_init(DS1302_CE_PINX, GPO, GPI_DISAB);
switch (month) //gpio_Interrupt_init(DS1302_CLK_PINX, GPO, GPI_DISAB);
{ gpio_init(DS1302_CE_PINX, 1, 0);
case 4: gpio_init(DS1302_CLK_PINX, 1, 0);
case 6: gpio_Interrupt_init(DS1302_IO_PINX, GPI_UP_PF, GPI_DISAB);
case 9:
case 11: // 使能写
return 30; ds1302_single_write(7, 0x00);
case 2: // 当ds1302掉电时设置时间初始值
if (is_leapyear(year)) if ((ds1302_single_read(0) & 0x80) == 1)
return 29; {
else calendar_info sys_cal = { 0, 1, 2, 3, 4, 2012, 0, 1 };
return 28; ds1302_set_time(&sys_cal);
default: }
return 31; return;
} }
}
static void ds1302_byte_write(uint8_t data) /**
{ * is_leapyear() - 判断是否为闰年
gpio_init(DS1302_IO_PINX, 1, 0); * @year: 要判断的年份
for (uint8_t mask = 0x01; mask != 0; mask <<= 1) *
{ * 是闰年返回1，不是闰年返回0
gpio_set(DS1302_CLK_PINX, 0); */
if (data & mask) uint8_t is_leapyear(uint16_t year)
{ {
gpio_set(DS1302_IO_PINX, 1); return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
} }
else
{ /**
gpio_set(DS1302_IO_PINX, 0); * get_month_days() - 得到给定年份和月份时对应月份的天数
} * @year: 给定年份
// tdc,200ns,数据建立时间,tcl,1000ns,sclk低电平保持时间 * @month: 给定月份
for (uint8_t i = 0; i < 50; i++); *
gpio_set(DS1302_CLK_PINX, 1); * 返回值为对应的月份的天数
// tcdh,280ns,数据采集时间,tch,1000ns,sclk高电平保持时间 */
for (uint8_t i = 0; i < 50; i++); uint8_t get_month_days(uint16_t year, uint8_t month)
} {
return; switch (month)
} {
case 4:
static uint8_t ds1302_byte_read(void) case 6:
{ case 9:
uint8_t data = 0; case 11:
return 30;
//gpio_init(DS1302_IO_PINX, 0, 1); case 2:
gpio_Interrupt_init(DS1302_IO_PINX, GPI_UP_PF, GPI_DISAB); if (is_leapyear(year))
gpio_set(DS1302_CLK_PINX, 1); return 29;
// tccz,280ns,sclk到高阻态 else
for (uint8_t i = 0; i < 50; i++); return 28;
for (uint8_t mask = 0x01; mask != 0; mask <<= 1) default:
{ return 31;
gpio_set(DS1302_CLK_PINX, 0); // 产生下降沿 }
// tcdd,800ns,数据输出延迟 }
for (uint8_t i = 0; i < 50; i++);
for (uint8_t i = 0; i < 50; i++); /**
if (gpio_get(DS1302_IO_PINX)) * ds1302_byte_write() - 向ds1302写入一个字节
{ * @data: 要写入的字节
data |= mask; */
} static void ds1302_byte_write(uint8_t data)
gpio_set(DS1302_CLK_PINX, 1); {
// tccz,280ns,sclk到高阻态 gpio_init(DS1302_IO_PINX, 1, 0);
for (uint8_t i = 0; i < 50; i++); for (uint8_t mask = 0x01; mask != 0; mask <<= 1)
} {
return data; gpio_set(DS1302_CLK_PINX, 0);
} if (data & mask)
{
gpio_set(DS1302_IO_PINX, 1);
}
else
static uint8_t ds1302_single_read(uint8_t addr) {
{ gpio_set(DS1302_IO_PINX, 0);
uint8_t cmd = 0, }
data = 0; // tdc,200ns,数据建立时间,tcl,1000ns,sclk低电平保持时间
for (uint8_t i = 0; i < 50; i++);
cmd = (1 << 7) | (addr << 1) | 1; gpio_set(DS1302_CLK_PINX, 1);
/* // tcdh,280ns,数据采集时间,tch,1000ns,sclk高电平保持时间
* 初始化ce和clk状态 for (uint8_t i = 0; i < 50; i++);
*/ }
gpio_set(DS1302_CE_PINX, 0); return;
for (uint8_t i = 0; i < 50; i++); }
gpio_set(DS1302_CLK_PINX, 0);
for (uint8_t i = 0; i < 50; i++); /**
* ds1302_byte_read() - 从ds1302读取一个字节
gpio_set(DS1302_CE_PINX, 1); *
// tcc,ce到时钟建立时间，4us * 返回读取到的字节
for (uint8_t i = 0; i < 200; i++); */
ds1302_byte_write(cmd); static uint8_t ds1302_byte_read(void)
data = ds1302_byte_read(); {
gpio_set(DS1302_CE_PINX, 0); uint8_t data = 0;
// tcdz,ce到高阻态时间，280ns
for (uint8_t i = 0; i < 20; i++); //gpio_init(DS1302_IO_PINX, 0, 1);
return data; gpio_Interrupt_init(DS1302_IO_PINX, GPI_UP_PF, GPI_DISAB);
} gpio_set(DS1302_CLK_PINX, 1);
// tccz,280ns,sclk到高阻态
void ds1302_single_write(uint8_t addr, uint8_t data) for (uint8_t i = 0; i < 50; i++);
{ for (uint8_t mask = 0x01; mask != 0; mask <<= 1)
uint8_t cmd = 0; {
gpio_set(DS1302_CLK_PINX, 0); // 产生下降沿
cmd = (1 << 7) | (addr << 1); // tcdd,800ns,数据输出延迟
/* for (uint8_t i = 0; i < 50; i++);
* 初始化ce和clk状态 for (uint8_t i = 0; i < 50; i++);
*/ if (gpio_get(DS1302_IO_PINX))
gpio_set(DS1302_CE_PINX, 0); {
for (uint8_t i = 0; i < 50; i++); data |= mask;
gpio_set(DS1302_CLK_PINX, 0); }
for (uint8_t i = 0; i < 50; i++); gpio_set(DS1302_CLK_PINX, 1);
// tccz,280ns,sclk到高阻态
gpio_set(DS1302_CE_PINX, 1); for (uint8_t i = 0; i < 50; i++);
// tcc,ce到时钟建立时间，4us }
for (uint8_t i = 0; i < 200; i++); return data;
ds1302_byte_write(cmd); }
ds1302_byte_write(data);
gpio_set(DS1302_CE_PINX, 0);
return;
} /**
* ds1302_single_read() - ds1302在单字节模式下读取一个地址上的数据
void ds1302_set_time(calendar_info *cal) * @addr: 要读取的地址
{ *
ds1302_single_write(7, 0x00); * 返回读取的到的字节值
ds1302_single_write(0, cal->sec % 10 + (cal->sec / 10 << 4)); */
ds1302_single_write(1, cal->min % 10 + (cal->min / 10 << 4)); static uint8_t ds1302_single_read(uint8_t addr)
ds1302_single_write(2, cal->hour % 10 + (cal->hour / 10 << 4)); {
ds1302_single_write(3, cal->mday % 10 + (cal->mday / 10 << 4)); uint8_t cmd = 0,
ds1302_single_write(4, cal->month % 10 + (cal->month / 10 << 4)); data = 0;
ds1302_single_write(5, cal->wday);
ds1302_single_write(6, (cal->year - 2000) % 10 + ((cal->year - 2000) / 10 << 4)); cmd = (1 << 7) | (addr << 1) | 1;
return; /*
} * 初始化ce和clk状态
*/
void ds1302_read_time(calendar_info *cal) gpio_set(DS1302_CE_PINX, 0);
{ for (uint8_t i = 0; i < 50; i++);
uint8_t rval; gpio_set(DS1302_CLK_PINX, 0);
for (uint8_t i = 0; i < 50; i++);
rval = ds1302_single_read(0);
cal->sec = (rval & 0x0f) + ((rval & 0x70) >> 4) * 10; gpio_set(DS1302_CE_PINX, 1);
rval = ds1302_single_read(1); // tcc,ce到时钟建立时间，4us
cal->min = (rval & 0x0f) + ((rval & 0x70) >> 4) * 10; for (uint8_t i = 0; i < 200; i++);
rval = ds1302_single_read(2); ds1302_byte_write(cmd);
cal->hour = (rval & 0x0f) + ((rval & 0x30) >> 4) * 10; data = ds1302_byte_read();
rval = ds1302_single_read(3); gpio_set(DS1302_CE_PINX, 0);
cal->mday = (rval & 0x0f) + ((rval & 0x30) >> 4) * 10; // tcdz,ce到高阻态时间，280ns
rval = ds1302_single_read(4); for (uint8_t i = 0; i < 20; i++);
cal->month = (rval & 0x0f) + ((rval & 0x10) >> 4) * 10; return data;
rval = ds1302_single_read(5); }
cal->wday = rval & 0x07;
rval = ds1302_single_read(6); /**
cal->year = (rval & 0x0f) + ((rval & 0xf0) >> 4) * 10 + 2000; * ds1302_single_write() - 在单字节模式下向ds1302的一个地址上写入一个字节的数据
* @addr: 要写入数据的地址
return; * @data: 要写入的数据
} */
void ds1302_single_write(uint8_t addr, uint8_t data)
void ds1302_init(void) {
{ uint8_t cmd = 0;
//gpio_Interrupt_init(DS1302_CE_PINX, GPO, GPI_DISAB);
//gpio_Interrupt_init(DS1302_CLK_PINX, GPO, GPI_DISAB); cmd = (1 << 7) | (addr << 1);
gpio_init(DS1302_CE_PINX, 1, 0); /*
gpio_init(DS1302_CLK_PINX, 1, 0); * 初始化ce和clk状态
gpio_Interrupt_init(DS1302_IO_PINX, GPI_UP_PF, GPI_DISAB); */
ds1302_single_write(7, 0x00); gpio_set(DS1302_CE_PINX, 0);
if ((ds1302_single_read(0) & 0x80) == 1) for (uint8_t i = 0; i < 50; i++);
{ gpio_set(DS1302_CLK_PINX, 0);
calendar_info sys_cal = { 0, 1, 2, 3, 4, 2012, 0, 1 }; for (uint8_t i = 0; i < 50; i++);
ds1302_set_time(&sys_cal);
} gpio_set(DS1302_CE_PINX, 1);
return; // tcc,ce到时钟建立时间，4us
} for (uint8_t i = 0; i < 200; i++);
ds1302_byte_write(cmd);
ds1302_byte_write(data);
gpio_set(DS1302_CE_PINX, 0);
/* return;
* 这个函数需要按所需的时间精度来定时调用 }
*/
void maintain_system_time(void) /**
{ * ds1302_set_time() - 向ds1302中写入时间
enter_critical(); * @cal: 要写入的时间值地址
ds1302_read_time(&system_time); */
exit_critical(); void ds1302_set_time(calendar_info *cal)
return; {
} ds1302_single_write(7, 0x00);
ds1302_single_write(0, cal->sec % 10 + (cal->sec / 10 << 4));
calendar_info get_system_time(void) ds1302_single_write(1, cal->min % 10 + (cal->min / 10 << 4));
{ ds1302_single_write(2, cal->hour % 10 + (cal->hour / 10 << 4));
return system_time; ds1302_single_write(3, cal->mday % 10 + (cal->mday / 10 << 4));
} ds1302_single_write(4, cal->month % 10 + (cal->month / 10 << 4));
ds1302_single_write(5, cal->wday);
ds1302_single_write(6, (cal->year - 2000) % 10 + ((cal->year - 2000) / 10 << 4));
return;
/*************************************************************/ }
/**
uint32_t calendar_to_sec(calendar_info *cal) * ds1302_read_time() - 从ds1302中读取时间
{ * @cal: 读取的时间值被存放的地址
uint32_t sec = cal->sec; */
uint32_t year = cal->year; void ds1302_read_time(calendar_info *cal)
uint32_t month = cal->month; {
uint8_t rval;
if (year < START_YEAR || year > (START_YEAR + 135))
return 0; rval = ds1302_single_read(0);
cal->sec = (rval & 0x0f) + ((rval & 0x70) >> 4) * 10;
sec += (uint32_t)cal->min * 60; rval = ds1302_single_read(1);
sec += (uint32_t)cal->hour * 3600; cal->min = (rval & 0x0f) + ((rval & 0x70) >> 4) * 10;
sec += (uint32_t)(cal->mday - 1) * SEC_IN_DAY; rval = ds1302_single_read(2);
if (is_leapyear(year)) cal->hour = (rval & 0x0f) + ((rval & 0x30) >> 4) * 10;
{ rval = ds1302_single_read(3);
while (month > 1) cal->mday = (rval & 0x0f) + ((rval & 0x30) >> 4) * 10;
{ rval = ds1302_single_read(4);
sec += (uint32_t)day_leap[--month] * SEC_IN_DAY; cal->month = (rval & 0x0f) + ((rval & 0x10) >> 4) * 10;
} rval = ds1302_single_read(5);
} cal->wday = rval & 0x07;
else rval = ds1302_single_read(6);
{ cal->year = (rval & 0x0f) + ((rval & 0xf0) >> 4) * 10 + 2000;
while (month > 1)
{ return;
sec += (uint32_t)day_noleap[--month] * SEC_IN_DAY; }
}
} /**
while (year > START_YEAR) * maintain_system_time() - 设置系统时间变量
{ *
sec += (uint32_t)DAY_IN_YEAR(--year) * SEC_IN_DAY; * 这个函数需要按所需的时间精度来定时调用
} */
return sec; void maintain_system_time(void)
} {
enter_critical();
calendar_info sec_to_calendar(uint32_t sec) ds1302_read_time(&system_time);
{ exit_critical();
calendar_info cal; return;
uint32_t day, left; }
cal.year = START_YEAR; /**
cal.month = 1; * get_system_time() - 返回系统时间
cal.mday = 1; */
cal.yday = 1; calendar_info get_system_time(void)
cal.wday = ymd_to_wday(START_YEAR, 1, 1); {
return system_time;
day = sec / SEC_IN_DAY; }
left = sec % SEC_IN_DAY;
cal.wday = (day + cal.wday) % 7;
cal.hour = left / 3600; /**
cal.min = left / 60 % 60; * calendar_to_sec() - 分解时间到日历时间的转换
cal.sec = left % 60; * @cal: 被转换的分解时间
*
while (day >= DAY_IN_YEAR(cal.year)) * 返回的是日历时间，即从某一个时间点到当前转换时间所经过的秒数
{ */
day -= DAY_IN_YEAR(cal.year++); uint32_t calendar_to_sec(calendar_info *cal)
} {
cal.yday += day; uint32_t sec = cal->sec;
uint32_t year = cal->year;
if (is_leapyear(cal.year)) uint32_t month = cal->month;
{
while (day >= day_leap[cal.month]) if (year < START_YEAR || year > (START_YEAR + 135))
{ return 0;
day -= day_leap[cal.month++];
} sec += (uint32_t)cal->min * 60;
} sec += (uint32_t)cal->hour * 3600;
else sec += (uint32_t)(cal->mday - 1) * SEC_IN_DAY;
{ if (is_leapyear(year))
while (day >= day_noleap[cal.month]) {
{ while (month > 1)
day -= day_noleap[cal.month++]; {
} sec += (uint32_t)day_leap[--month] * SEC_IN_DAY;
} }
cal.mday += day; }
else
return cal; {
} while (month > 1)
{
sec += (uint32_t)day_noleap[--month] * SEC_IN_DAY;
static int16_t ymd_to_wday(int16_t year, int16_t month, int16_t mday) }
{ }
if (is_leapyear(year)) while (year > START_YEAR)
{ {
for (uint8_t i = 1; i < month; i++) sec += (uint32_t)DAY_IN_YEAR(--year) * SEC_IN_DAY;
mday += day_leap[i]; }
} return sec;
else }
{
for (uint8_t i = 1; i < month; i++) /**
mday += day_noleap[i]; * sec_to_calendar() - 日历时间到分解时间的转换
} * @cal: 被转换的日历时间
return (year + year / 4 - year / 100 + year / 400 + mday) % 7; *
} * 返回的是分解时间，即以年月日时分秒形式表示的时间
*/
calendar_info sec_to_calendar(uint32_t sec)
{
calendar_info cal;
uint32_t day, left;
cal.year = START_YEAR;
cal.month = 1;
cal.mday = 1;
cal.yday = 1;
cal.wday = ymd_to_wday(START_YEAR, 1, 1);
day = sec / SEC_IN_DAY;
left = sec % SEC_IN_DAY;
cal.wday = (day + cal.wday) % 7;
cal.hour = left / 3600;
cal.min = left / 60 % 60;
cal.sec = left % 60;
while (day >= DAY_IN_YEAR(cal.year))
{
day -= DAY_IN_YEAR(cal.year++);
}
cal.yday += day;
if (is_leapyear(cal.year))
{
while (day >= day_leap[cal.month])
{
day -= day_leap[cal.month++];
}
}
else
{
while (day >= day_noleap[cal.month])
{
day -= day_noleap[cal.month++];
}
}
cal.mday += day;
return cal;
}
/**
* ymd_to_wday() - 从年份、月份、天数这三个数据得到对应在一个星期中的天数
* @year: 年份
* @month: 月份
* @mday: 当前月中已经过的天数
*
* 返回对应的一个星期中的天数
*/
static int16_t ymd_to_wday(int16_t year, int16_t month, int16_t mday)
{
if (is_leapyear(year))
{
for (uint8_t i = 1; i < month; i++)
mday += day_leap[i];
}
else
{
for (uint8_t i = 1; i < month; i++)
mday += day_noleap[i];
}
return (year + year / 4 - year / 100 + year / 400 + mday) % 7;
}

321
plan_manage_main/src/app/simulat_timer.c
View file

@ -1,160 +1,161 @@
/* /*
* simulat_timer.h - 实现一个模拟定时器 * simulat_timer.h - 实现一个模拟定时器
*/ */
#include "include.h" #include "include.h"
#include "include/simulat_timer.h" #include "include/config.h"
#include "include/config.h" #include "include/key.h"
#include "include/key.h"
#include "include/simulat_timer.h"
static volatile st_register st_r[SIMULAT_TIMER_NUM];
static volatile st_register st_r[SIMULAT_TIMER_NUM];
/*
* st_init() - 初始化实现模拟定时器所需的pit定时器 /**
* * st_init() - 初始化实现模拟定时器所需的pit定时器
* 基础定时为1ms *
*/ * 基础定时为1ms
void st_base_init(void) */
{ void st_base_init(void)
uint32_t cnt; {
uint32_t cnt;
cnt = bus_clk_khz * 1;
pit_init(SIMULAT_TIMER_PITX, cnt); // 1ms硬件定时中断周期 cnt = bus_clk_khz * 1;
return; pit_init(SIMULAT_TIMER_PITX, cnt); // 1ms硬件定时中断周期
} return;
}
/*
* st_init() - 初始化一个给定编号的模拟定时器 /**
* @n: 定时器编号 * st_init() - 初始化一个给定编号的模拟定时器
* @st_m: 定时模式 * @n: 定时器编号
* @cmr_v: 定时器比较值，在非比较模式可以为任意值 * @st_m: 定时模式
* * @cmr_v: 定时器比较值，在非比较模式可以为任意值
* 这个函数返回0表示正常完成了初始化任务，返回~0表示定时器已打开或不存在 *
*/ * 这个函数返回0表示正常完成了初始化任务，返回~0表示定时器已打开或不存在
uint8_t st_init(uint8_t n, st_mode st_m, uint32_t cmr_v) */
{ uint8_t st_init(uint8_t n, st_mode st_m, uint32_t cmr_v)
if (st_r[n].flag.ten == 1 || n >= SIMULAT_TIMER_NUM) {
{ if (st_r[n].flag.ten == 1 || n >= SIMULAT_TIMER_NUM)
return ~0; {
} return ~0;
st_r[n].flag.ten = 1; }
switch(st_m) st_r[n].flag.ten = 1;
{ switch(st_m)
case COMPARE: {
st_r[n].flag.tfc = 1; case COMPARE:
st_r[n].cmr = cmr_v; st_r[n].flag.tfc = 1;
break; st_r[n].cmr = cmr_v;
case NO_COMPARE: break;
st_r[n].flag.tfc = 0; case NO_COMPARE:
break; st_r[n].flag.tfc = 0;
default: break;
break; default:
} break;
return 0; }
} return 0;
}
/*
* st_close() - 关闭一个给定编号的模拟定时器 /**
* @n: 定时器编号 * st_close() - 关闭一个给定编号的模拟定时器
*/ * @n: 定时器编号
void st_close(uint8_t n) */
{ void st_close(uint8_t n)
st_r[n].flag.ten = 0; {
return; st_r[n].flag.ten = 0;
} return;
}
/*
* st_tcf() - 查询tcf位返回 /**
* @n: 定时器编号 * st_tcf() - 查询tcf位返回
* * @n: 定时器编号
* 这个函数在没有过比较值的时候返回0，已过比较值得时候返回1，对于不存在或未打开 *
*/ * 这个函数在没有过比较值的时候返回0，已过比较值得时候返回1，对于不存在或未打开
uint8_t st_tcf(uint8_t n) */
{ uint8_t st_tcf(uint8_t n)
uint8_t temp; {
uint8_t temp;
if (st_r[n].flag.tcf == 1)
{ if (st_r[n].flag.tcf == 1)
st_r[n].flag.tcf = 0; {
temp = 1; st_r[n].flag.tcf = 0;
} temp = 1;
else }
{ else
temp = 0; {
} temp = 0;
return temp; }
} return temp;
}
/*
* st_tov() - 查询tov位返回 /**
* @n: 定时器编号 * st_tov() - 查询tov位返回
* * @n: 定时器编号
* 这个函数在没有溢出时返回0，没有溢出时返回1，对于不存在或未打开 *
*/ * 这个函数在没有溢出时返回0，没有溢出时返回1，对于不存在或未打开
uint8_t st_tov(uint8_t n) */
{ uint8_t st_tov(uint8_t n)
uint8_t temp; {
if (st_r[n].flag.tov == 1) uint8_t temp;
{ if (st_r[n].flag.tov == 1)
st_r[n].flag.tov = 0; {
temp = 1; st_r[n].flag.tov = 0;
} temp = 1;
else }
{ else
temp = 0; {
} temp = 0;
return temp; }
} return temp;
}
/*
* st_count() - 查询当前模拟定时值 /**
* @n: 定时器编号 * st_count() - 查询当前模拟定时值
* * @n: 定时器编号
* 对于不存在或未打开 *
*/ * 对于不存在或未打开
uint32_t st_count(uint8_t n) */
{ uint32_t st_count(uint8_t n)
return st_r[n].count; {
} return st_r[n].count;
}
/*
* st_base() -定时调用以模拟N路定时器 /**
* * st_base() -定时调用以模拟N路定时器
* 定时的最小间隔等于这个函数被调用的周期 *
*/ * 定时的最小间隔等于这个函数被调用的周期
void st_base(void) */
{ void st_base(void)
uint8_t i; {
uint8_t i;
for (i = 0; i < SIMULAT_TIMER_NUM; i++)
{ for (i = 0; i < SIMULAT_TIMER_NUM; i++)
if (st_r[i].flag.ten == 1) // 使能 {
{ if (st_r[i].flag.ten == 1) // 使能
if (++st_r[i].count == 0) // 溢出 {
{ if (++st_r[i].count == 0) // 溢出
st_r[i].flag.tov = 1; {
} // 溢出 st_r[i].flag.tov = 1;
if (st_r[i].flag.tfc == 1) // 比较 } // 溢出
{ if (st_r[i].flag.tfc == 1) // 比较
if (st_r[i].count == st_r[i].cmr) {
{ if (st_r[i].count == st_r[i].cmr)
st_r[i].count = 0; {
st_r[i].flag.tcf = 1; st_r[i].count = 0;
} st_r[i].flag.tcf = 1;
} // 比较 }
} // 使能 } // 比较
} } // 使能
}
if (st_tcf(0) == 1)
{ if (st_tcf(0) == 1)
key_detect(); {
} key_detect();
}
return;
} return;
}

698
plan_manage_main/src/app/tft.c
View file

File diff suppressed because it is too large Load diff

14
settings/plan_manage.wsdt
View file

File diff suppressed because one or more lines are too long

2
settings/plan_manage.wspos
View file

@ -1,2 +1,2 @@
[MainWindow] [MainWindow]
WindowPlacement=_ 125 87 1150 613 2 WindowPlacement=_ 139 121 1164 647 3