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
"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
ByteLimit=50
[DebugChecksum]
Checksum=231404021
Checksum=2097835749
[CodeCoverage]
Enabled=_ 0
[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 - 监测并采集按键的输入
* 共有四种输入，无键，单击，双击，长击。
* 使用一个定时器每10ms采集一次io状态来实现的。
*/
#ifndef KEY_H
#define KEY_H
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_init() - 按键模块初始化
*
*/
void key_init(void);
/*
* key_detect() - 检测按键
*
* 要求每隔10ms调用一次
*/
void key_detect(void);
/*
* get_key_mean() - 得到指定的按键信息
*
* 这个函数中在取得信息后会将对应按键重新标记为N_KEY
*/
key_mean get_key_mean(key_type key_t);
void clear_key_m(void);
#endif // KEY_H
/* key.h - 监测并采集按键的输入
* 共有四种输入，无键，单击，双击，长击。
* 使用一个定时器每10ms采集一次io状态来实现的。
*/
#ifndef KEY_H
#define KEY_H
/*
* key_mean - 按键的状态标志符号
* N_KEY表示无键按下状态，S_KEY表示单击，D_KEY表示双击，L_KEY表示长按
*/
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;
void key_init(void);
void key_detect(void);
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 - 提供旋钮输入的接口函数
*
* 使用的是一个数字旋钮，利用计数来采集输入
*/
#ifndef KNOB_H
#define KNOB_H
#include "arm_cm0.h"
#include "vectors.h"
/*
* knob_init() - 为旋钮输入而执行的初始化
*
* 旋钮的检测初始化后默认是禁止的
*/
void knob_init(void);
/*
* knob_enable() - 使能旋钮脉冲检测
*/
void knob_enable(void);
/*
* 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 */
/*
* knob.h - 提供旋钮输入的接口函数
*
* 使用的是一个数字旋钮，利用计数来采集输入
*/
#ifndef KNOB_H
#define KNOB_H
void knob_init(void);
void knob_enable(void);
void knob_disable(void);
void knob_clear(void);
int32_t get_knob_val(void);
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 - 时间处理
*/
#include <stdint.h>
typedef struct calendar_info_
{
uint8_t sec;
uint8_t min;
uint8_t hour;
uint8_t mday;
uint8_t month;
uint16_t year;
uint8_t wday;
uint16_t yday;
} calendar_info;
enum { START_YEAR = 2000, SEC_IN_DAY = 24 * 60 * 60};
uint8_t is_leapyear(uint16_t year);
uint8_t get_month_days(uint16_t year, uint8_t month);
void ds1302_init(void);
void ds1302_set_time(calendar_info *cal);
void ds1302_read_time(calendar_info *cal);
void maintain_system_time(void);
calendar_info get_system_time(void);
uint32_t calendar_to_sec(calendar_info *cal);
calendar_info sec_to_calendar(uint32_t sec);
/*
* time.h - 时间处理
*/
#include <stdint.h>
/*
* calendar_info - 分解时间
*/
typedef struct calendar_info_
{
uint8_t sec;
uint8_t min;
uint8_t hour;
uint8_t mday;
uint8_t month;
uint16_t year;
uint8_t wday;
uint16_t yday;
} calendar_info;
// START_YEAR为计算日历时间时的起始时间
enum { START_YEAR = 2000, SEC_IN_DAY = 24 * 60 * 60};
uint8_t is_leapyear(uint16_t year);
uint8_t get_month_days(uint16_t year, uint8_t month);
void ds1302_init(void);
void ds1302_set_time(calendar_info *cal);
void ds1302_read_time(calendar_info *cal);
void maintain_system_time(void);
calendar_info get_system_time(void);
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 - 实现一个模拟定时器
*/
#ifndef SIMULAT_TIMER_H
#define SIMULAT_TIMER_H
#include <stdint.h>
/*
* 模拟定时器的数量
*/
#define SIMULAT_TIMER_NUM 5
typedef struct st_register_
{
uint32_t count; // 定时器计数
uint32_t cmr; // 比较寄存器
struct
{
uint8_t ten : 1; // 使能标志
uint8_t tov : 1; // 溢出标志
uint8_t tfc : 1; // 自由运行标志
uint8_t tcf : 1; // 比较标志
} flag;
} st_register;
typedef enum st_mode_
{
COMPARE = 0,
NO_COMPARE
} st_mode;
/*
* st_init() - 初始化实现模拟定时器所需的pit定时器
*
* 基础定时为1ms
*/
void st_base_init(void);
/*
* st_init() - 初始化一个给定编号的模拟定时器
* @n: 定时器编号
* @st_m: 定时模式
* @cmr_v: 定时器比较值，在非比较模式可以为任意值
*
* 这个函数返回0表示正常完成了初始化任务，返回~0表示定时器已打开或不存在
*/
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 */
/*
* simulat_timer.h - 实现一个模拟定时器
*/
#ifndef SIMULAT_TIMER_H
#define SIMULAT_TIMER_H
#include <stdint.h>
/*
* 模拟定时器的数量
*/
#define SIMULAT_TIMER_NUM 5
typedef struct st_register_
{
uint32_t count; // 定时器计数
uint32_t cmr; // 比较寄存器
struct
{
uint8_t ten : 1; // 使能标志
uint8_t tov : 1; // 溢出标志
uint8_t tfc : 1; // 自由运行标志
uint8_t tcf : 1; // 比较标志
} flag;
} st_register;
typedef enum st_mode_
{
COMPARE = 0,
NO_COMPARE
} st_mode;
void st_base_init(void);
uint8_t st_init(uint8_t n, st_mode st_m, uint32_t cmr_v);
void st_close(uint8_t n);
uint8_t st_tcf(uint8_t n);
uint8_t st_tov(uint8_t n);
uint32_t st_count(uint8_t 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½Ó¿Ú
*/
#ifndef TFT_H
#define TFT_H
typedef struct input_limit_
{
int16_t max;
int16_t min;
} input_limit;
void tft_init(void);
void tft_send_cmd(const char *cmd);
void tft_left(void);
void tft_right(void);
void tft_up(void);
void tft_down(void);
void tft_ok(void);
void tft_ret(void);
void tft_page_refresh(void);
int16_t *get_value_of_kvp(char *name, uint8_t objn);
input_limit tft_input_limit(char *name);
//const kv_pair *get_plan_data(uint8_t objn)[][PLAN_DATA_NUM];
#endif /* TFT_H */
/*
* tft.h - tft½Ó¿Ú
*/
#ifndef TFT_H
#define TFT_H
typedef struct input_limit_
{
int16_t max;
int16_t min;
} input_limit;
void tft_init(void);
void tft_send_cmd(const char *cmd);
void tft_left(void);
void tft_right(void);
void tft_up(void);
void tft_down(void);
void tft_ok(void);
void tft_ret(void);
void tft_page_refresh(void);
int16_t *get_value_of_kvp(char *name, uint8_t objn);
input_limit tft_input_limit(char *name);
#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和plan_handle模块
*/
#include "include/pm_time.h"
typedef struct plan_input_
{
calendar_info bg_t;
calendar_info ed_t;
calendar_info pd_t;
uint8_t x_orient;
uint8_t y_orient;
uint8_t lg_r : 1;
uint8_t lg_b : 1;
uint8_t lg_uvb : 1;
uint8_t water : 1;
uint8_t sw : 1;
uint8_t cnt;
} plan_input;
typedef struct kv_pair_
{
char *key;
int16_t value;
int8_t attr;
} kv_pair;
enum { PLAN_DATA_NUM = 19 };
extern plan_input plan_in[PLAN_DATA_NUM];
extern kv_pair kvp_obj_set[][PLAN_DATA_NUM];
void tft_to_plan_input(uint8_t objn);
/*
* tft_handle_internal.h - tft和plan_handle模块共同使用部分的内部声明
*
* 这个文件只应包含在tft和plan_handle模块
*/
#include "include/pm_time.h"
/*
* plan_input - 表示计划输入的类型
*
*/
typedef struct plan_input_
{
calendar_info bg_t; // 开始时间
calendar_info ed_t; // 结束时间
calendar_info pd_t; // 周期时长
uint8_t x_orient; // x方向值，未使用
uint8_t y_orient; // y方向值，未使用
uint8_t lg_r : 1; // 红灯
uint8_t lg_b : 1; // 蓝灯
uint8_t lg_uvb : 1; // uvb
uint8_t water : 1; // 浇水，未使用
uint8_t sw : 1; // 是否加入计划
uint8_t cnt; // 完成次数
} plan_input;
/*
* kv_pair - 表示页面中的元素
* key为存储元素ID的字符串，value为一个整形值，attr为元素属性
*/
typedef struct kv_pair_
{
char *key;
int16_t value;
int8_t attr;
} kv_pair;
enum { PLAN_DATA_NUM = 19, OBJ_NUM = 8 };
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);
uint16_t get_moisture(void);
void water_ctr(uint16_t sv_moist);

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

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

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

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

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

@ -1,120 +1,120 @@
/*
* orient.c - 关于光照方向控制的模块
*
* 所有如上，所有如下
*/
#include "uart.h"
#include "include/orient.h"
#include "include/config.h"
void orient_init(void)
{
uart_init(ORIENT_UARTX, 2400);
gpio_init(RE_DE_PINX, 1, 1);
orient_setmode(0, MODE_MANUL);
orient_setmode(1, MODE_MANUL);
return;
}
/*
* orient_setspeed() - 设置方向控制的速度以及角度
*
* @addr: 地址码
* @ori: 方向
* @spd: 表示速度，范围在0~100
*/
void orient_setspeed(uint8_t addr, orient ori, uint8_t spd)
{
uint8_t cmd[7] = { 0xff, addr, 0x00, 0x00, 0x00, 0x00, 0x00 };
switch (ori)
{
case ORIENT_UP:
cmd[3] = 0x08;
break;
case ORIENT_DOWN:
cmd[3] = 0x10;
break;
case ORIENT_LEFT:
cmd[3] = 0x04;
break;
case ORIENT_RIGHT:
cmd[3] = 0x02;
default:
break;
}
if (spd > 100)
{
spd = 100;
}
cmd[4] = 0x3f * spd / 100;
cmd[6] = cmd[1] + cmd[2] + cmd[3] + cmd[4] + cmd[5];
uart_sendN(ORIENT_UARTX, cmd, 7);
return;
}
/*
* orient_presetop() - 设置预置点
*
* @addr: 地址码
* @op: 对预置点的操作
* @npre: 预置点编号
*/
void orient_presetop(uint8_t addr, preset_op op, uint8_t npre)
{
uint8_t cmd[7] = { 0xff, addr, 0x00, 0x00, 0x00, npre, 0x00 };
switch (op)
{
case PRESET_SET:
cmd[3] = 0x03;
break;
case PRESET_CALL:
cmd[3] = 0x07;
break;
case PRESET_CLEAR:
cmd[3] = 0x05;
break;
default:
break;
}
cmd[6] = cmd[1] + cmd[2] + cmd[3] + cmd[4] + cmd[5];
uart_sendN(ORIENT_UARTX, cmd, 7);
return;
}
/*
* orient_setmode() - 设置云台模式
*
* @addr: 地址码
* @mod: 模式标志
*/
void orient_setmode(uint8_t addr, orient_mode mod)
{
uint8_t cmd[7] = { 0xff, addr, 0x00, 0x00, 0x00, 0x00, 0x00 };
switch (mod)
{
case MODE_AUTO:
cmd[2] = 0x90;
break;
case MODE_MANUL:
cmd[2] = 0x00;
break;
default:
break;
}
cmd[6] = cmd[1] + cmd[2] + cmd[3] + cmd[4] + cmd[5];
uart_sendN(ORIENT_UARTX, cmd, 7);
return;
}
/*
* orient.c - 关于光照方向控制的模块
*
* 所有如上，所有如下
*/
#include "uart.h"
#include "include/orient.h"
#include "include/config.h"
void orient_init(void)
{
uart_init(ORIENT_UARTX, 2400);
gpio_init(RE_DE_PINX, 1, 1);
orient_setmode(0, MODE_MANUL);
orient_setmode(1, MODE_MANUL);
return;
}
/*
* orient_setspeed() - 设置方向控制的速度以及角度
*
* @addr: 地址码
* @ori: 方向
* @spd: 表示速度，范围在0~100
*/
void orient_setspeed(uint8_t addr, orient ori, uint8_t spd)
{
uint8_t cmd[7] = { 0xff, addr, 0x00, 0x00, 0x00, 0x00, 0x00 };
switch (ori)
{
case ORIENT_UP:
cmd[3] = 0x08;
break;
case ORIENT_DOWN:
cmd[3] = 0x10;
break;
case ORIENT_LEFT:
cmd[3] = 0x04;
break;
case ORIENT_RIGHT:
cmd[3] = 0x02;
default:
break;
}
if (spd > 100)
{
spd = 100;
}
cmd[4] = (uint16_t)0x3f * spd / 100;
cmd[6] = cmd[1] + cmd[2] + cmd[3] + cmd[4] + cmd[5];
uart_sendN(ORIENT_UARTX, cmd, 7);
return;
}
/*
* orient_presetop() - 设置预置点
*
* @addr: 地址码
* @op: 对预置点的操作
* @npre: 预置点编号
*/
void orient_presetop(uint8_t addr, preset_op op, uint8_t npre)
{
uint8_t cmd[7] = { 0xff, addr, 0x00, 0x00, 0x00, npre, 0x00 };
switch (op)
{
case PRESET_SET:
cmd[3] = 0x03;
break;
case PRESET_CALL:
cmd[3] = 0x07;
break;
case PRESET_CLEAR:
cmd[3] = 0x05;
break;
default:
break;
}
cmd[6] = cmd[1] + cmd[2] + cmd[3] + cmd[4] + cmd[5];
uart_sendN(ORIENT_UARTX, cmd, 7);
return;
}
/*
* orient_setmode() - 设置云台模式
*
* @addr: 地址码
* @mod: 模式标志
*/
void orient_setmode(uint8_t addr, orient_mode mod)
{
uint8_t cmd[7] = { 0xff, addr, 0x00, 0x00, 0x00, 0x00, 0x00 };
switch (mod)
{
case MODE_AUTO:
cmd[2] = 0x90;
break;
case MODE_MANUL:
cmd[2] = 0x00;
break;
default:
break;
}
cmd[6] = cmd[1] + cmd[2] + cmd[3] + cmd[4] + cmd[5];
uart_sendN(ORIENT_UARTX, cmd, 7);
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读写模块
*/
#include "SSD_FTFx.h"
#include "pm_flash_cfg.h"
#define USED_SECTOR_NUM 0x01U
FLASH_SSD_CONFIG flashSSDConfig =
{
FTFx_REG_BASE, /* FTFx control register base */
PFLASH_BLOCK_BASE, /* base address of PFlash block */
PBLOCK_SIZE, /* size of PFlash block */
DEFLASH_BLOCK_BASE, /* base address of DFlash block */
0x0U, /* size of DFlash block */
EERAM_BLOCK_BASE, /* base address of EERAM block */
0x0U, /* size of EEE block */
DEBUGENABLE, /* background debug mode enable bit */
NULL_CALLBACK /* pointer to callback function */
};
#define LAUNCH_CMD_SIZE 0x80U
pFLASHCOMMANDSEQUENCE g_FlashLaunchCommand = (pFLASHCOMMANDSEQUENCE)0xFFFFFFFF;
uint16_t __ram_func[LAUNCH_CMD_SIZE/2]; /* array to copy __Launch_Command func to RAM */
void pm_flash_init(void)
{
uint32_t ret;
g_FlashLaunchCommand =
(pFLASHCOMMANDSEQUENCE)RelocateFunction((uint32_t)__ram_func ,
LAUNCH_CMD_SIZE ,(uint32_t)FlashCommandSequence);
ret = FlashInit(&flashSSDConfig);
if (FTFx_OK != ret)
{
ErrorTrap(ret);
}
return;
}
/*
* flash_write() - 将数据写入flash
* @saddr: 要写入的数据的起始地址
* @size: 写入数据的字节数，字节数必须要以4对齐！！！
*
* 这个函数的执行过程包括擦除和写入，默认的写入范围为flash的最后一个扇区，大小为
* 1KB，如果要改变大小，改参数就可以了，注意不要覆盖了code，具体可看map文件。
* 擦除是一次性擦除全部选择的扇区范围，所以在写入的时候要注意保存先前写入的数据
* flash读取函数的起始地址等于flash写入函数的写入起始地址
*/
void flash_write(uint8_t *saddr, uint16_t nbyte)
{
uint32_t ret;
uint32_t dest;
uint32_t size;
uint16_t number;
uint32_t temp;
/*
* 擦除扇区
*/
dest = flashSSDConfig.PFlashBlockBase + BYTE2WORD(flashSSDConfig.PFlashBlockSize
- USED_SECTOR_NUM * FTFx_PSECTOR_SIZE);
while ((dest + BYTE2WORD(FTFx_PSECTOR_SIZE)) <= (flashSSDConfig.PFlashBlockBase
+ BYTE2WORD(flashSSDConfig.PFlashBlockSize)))
{
size = FTFx_PSECTOR_SIZE;
ret = FlashEraseSector(&flashSSDConfig, dest, size, g_FlashLaunchCommand);
if (FTFx_OK != ret)
{
ErrorTrap(ret);
}
/* 检验 */
number = FTFx_PSECTOR_SIZE / PRD1SEC_ALIGN_SIZE;
for(uint8_t i = 0x0U; i < 0x2U; i++)
{
ret = FlashVerifySection(&flashSSDConfig, dest, number, i, g_FlashLaunchCommand);
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)))
{
ret = FlashProgram(&flashSSDConfig, dest, nbyte, \
saddr, g_FlashLaunchCommand);
if (FTFx_OK != ret)
{
ErrorTrap(ret);
}
/* 校验和检验 */
uint32_t sum = temp = 0x0U;
for (uint16_t i = 0x0U; i < nbyte; i++)
{
temp += saddr[i];
}
ret = FlashCheckSum(&flashSSDConfig, dest, nbyte, &sum);
if ((FTFx_OK != ret) || (temp != sum))
{
ErrorTrap(ret);
}
/* 正确测试 */
uint32_t FailAddr;
for (uint8_t i = 0x1U; i < 0x3U; i ++)
{
ret = FlashProgramCheck(&flashSSDConfig, dest, nbyte, saddr, \
&FailAddr, i, g_FlashLaunchCommand);
if (FTFx_OK != ret)
{
ErrorTrap(ret);
}
}
}
return;
}
/*
* flash_read() - 读取flash中写入的数据
* @daddr: 读取数据要保存的地址
* @nbyte: 要读取的字节数
*
* flash读取函数的起始地址等于flash写入函数的写入起始地址
*/
void flash_read(uint8_t *daddr, uint16_t nbyte)
{
uint8_t *saddr = (uint8_t *)(flashSSDConfig.PFlashBlockBase + BYTE2WORD(flashSSDConfig.PFlashBlockSize
- (uint32_t)(USED_SECTOR_NUM * FTFx_PSECTOR_SIZE)));
for (uint16_t i = 0; i < nbyte; i++)
{
daddr[i] = saddr[i];
}
return;
}
/*
* ErrorTrap() - flash操作错误处理
*/
void ErrorTrap(uint32_t ret)
{
while (1)
{
printf("flash操作错误，返回码为 %d\n", ret);
}
return;
}
/*
* pm_flash.c - flash读写模块
*/
#include "SSD_FTFx.h"
#include "pm_flash_cfg.h"
#define USED_SECTOR_NUM 0x01U
FLASH_SSD_CONFIG flashSSDConfig =
{
FTFx_REG_BASE, /* FTFx control register base */
PFLASH_BLOCK_BASE, /* base address of PFlash block */
PBLOCK_SIZE, /* size of PFlash block */
DEFLASH_BLOCK_BASE, /* base address of DFlash block */
0x0U, /* size of DFlash block */
EERAM_BLOCK_BASE, /* base address of EERAM block */
0x0U, /* size of EEE block */
DEBUGENABLE, /* background debug mode enable bit */
NULL_CALLBACK /* pointer to callback function */
};
#define LAUNCH_CMD_SIZE 0x80U
pFLASHCOMMANDSEQUENCE g_FlashLaunchCommand = (pFLASHCOMMANDSEQUENCE)0xFFFFFFFF;
/* array to copy __Launch_Command func to RAM */
uint16_t __ram_func[LAUNCH_CMD_SIZE/2];
void pm_flash_init(void)
{
uint32_t ret;
g_FlashLaunchCommand =
(pFLASHCOMMANDSEQUENCE)RelocateFunction((uint32_t)__ram_func ,
LAUNCH_CMD_SIZE ,(uint32_t)FlashCommandSequence);
ret = FlashInit(&flashSSDConfig);
if (FTFx_OK != ret)
{
ErrorTrap(ret);
}
return;
}
/*
* flash_write() - 将数据写入flash
* @saddr: 要写入的数据的起始地址
* @size: 写入数据的字节数，字节数必须要以4对齐！！！
*
* 这个函数的执行过程包括擦除和写入，默认的写入范围为flash的最后一个扇区，大小为
* 1KB，如果要改变大小，改参数就可以了，注意不要覆盖了code，具体可看map文件。
* 擦除是一次性擦除全部选择的扇区范围，所以在写入的时候要注意保存先前写入的数据
* flash读取函数的起始地址等于flash写入函数的写入起始地址
*/
void flash_write(uint8_t *saddr, uint16_t nbyte)
{
uint32_t ret;
uint32_t dest;
uint32_t size;
uint16_t number;
uint32_t temp;
/*
* 擦除扇区
*/
dest = flashSSDConfig.PFlashBlockBase + BYTE2WORD(
flashSSDConfig.PFlashBlockSize
- USED_SECTOR_NUM * FTFx_PSECTOR_SIZE);
while ((dest + BYTE2WORD(FTFx_PSECTOR_SIZE)) <=
(flashSSDConfig.PFlashBlockBase
+ BYTE2WORD(flashSSDConfig.PFlashBlockSize)))
{
size = FTFx_PSECTOR_SIZE;
ret = FlashEraseSector(&flashSSDConfig, dest, size,
g_FlashLaunchCommand);
if (FTFx_OK != ret)
{
ErrorTrap(ret);
}
/* 检验 */
number = FTFx_PSECTOR_SIZE / PRD1SEC_ALIGN_SIZE;
for(uint8_t i = 0x0U; i < 0x2U; i++)
{
ret = FlashVerifySection(&flashSSDConfig, dest, number, i,
g_FlashLaunchCommand);
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)))
{
ret = FlashProgram(&flashSSDConfig, dest, nbyte, \
saddr, g_FlashLaunchCommand);
if (FTFx_OK != ret)
{
ErrorTrap(ret);
}
/* 校验和检验 */
uint32_t sum = temp = 0x0U;
for (uint16_t i = 0x0U; i < nbyte; i++)
{
temp += saddr[i];
}
ret = FlashCheckSum(&flashSSDConfig, dest, nbyte, &sum);
if ((FTFx_OK != ret) || (temp != sum))
{
ErrorTrap(ret);
}
/* 正确测试 */
uint32_t FailAddr;
for (uint8_t i = 0x1U; i < 0x3U; i ++)
{
ret = FlashProgramCheck(&flashSSDConfig, dest, nbyte, saddr, \
&FailAddr, i, g_FlashLaunchCommand);
if (FTFx_OK != ret)
{
ErrorTrap(ret);
}
}
}
return;
}
/*
* flash_read() - 读取flash中写入的数据
* @daddr: 读取数据要保存的地址
* @nbyte: 要读取的字节数
*
* flash读取函数的起始地址等于flash写入函数的写入起始地址
*/
void flash_read(uint8_t *daddr, uint16_t nbyte)
{
uint8_t *saddr = (uint8_t *)(flashSSDConfig.PFlashBlockBase
+ BYTE2WORD(flashSSDConfig.PFlashBlockSize
- (uint32_t)(USED_SECTOR_NUM * FTFx_PSECTOR_SIZE)));
for (uint16_t i = 0; i < nbyte; i++)
{
daddr[i] = saddr[i];
}
return;
}
/*
* ErrorTrap() - flash操作错误处理
*/
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 - 时间处理
*/
#include "gpio.h"
#include "include/pm_time.h"
#include "include/config.h"
static calendar_info system_time;
#define DAY_IN_YEAR(nyear) (is_leapyear(nyear) ? 366 : 365)
static const uint8_t day_leap[] = {
0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
};
static const uint8_t day_noleap[] = {
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 int16_t ymd_to_wday(int16_t year, int16_t month, int16_t mday);
uint8_t is_leapyear(uint16_t year)
{
return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
}
uint8_t get_month_days(uint16_t year, uint8_t month)
{
switch (month)
{
case 4:
case 6:
case 9:
case 11:
return 30;
case 2:
if (is_leapyear(year))
return 29;
else
return 28;
default:
return 31;
}
}
static void ds1302_byte_write(uint8_t data)
{
gpio_init(DS1302_IO_PINX, 1, 0);
for (uint8_t mask = 0x01; mask != 0; mask <<= 1)
{
gpio_set(DS1302_CLK_PINX, 0);
if (data & mask)
{
gpio_set(DS1302_IO_PINX, 1);
}
else
{
gpio_set(DS1302_IO_PINX, 0);
}
// tdc,200ns,数据建立时间,tcl,1000ns,sclk低电平保持时间
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++);
}
return;
}
static uint8_t ds1302_byte_read(void)
{
uint8_t data = 0;
//gpio_init(DS1302_IO_PINX, 0, 1);
gpio_Interrupt_init(DS1302_IO_PINX, GPI_UP_PF, GPI_DISAB);
gpio_set(DS1302_CLK_PINX, 1);
// tccz,280ns,sclk到高阻态
for (uint8_t i = 0; i < 50; i++);
for (uint8_t mask = 0x01; mask != 0; mask <<= 1)
{
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))
{
data |= mask;
}
gpio_set(DS1302_CLK_PINX, 1);
// tccz,280ns,sclk到高阻态
for (uint8_t i = 0; i < 50; i++);
}
return data;
}
static uint8_t ds1302_single_read(uint8_t addr)
{
uint8_t cmd = 0,
data = 0;
cmd = (1 << 7) | (addr << 1) | 1;
/*
* 初始化ce和clk状态
*/
gpio_set(DS1302_CE_PINX, 0);
for (uint8_t i = 0; i < 50; i++);
gpio_set(DS1302_CLK_PINX, 0);
for (uint8_t i = 0; i < 50; i++);
gpio_set(DS1302_CE_PINX, 1);
// tcc,ce到时钟建立时间，4us
for (uint8_t i = 0; i < 200; i++);
ds1302_byte_write(cmd);
data = ds1302_byte_read();
gpio_set(DS1302_CE_PINX, 0);
// tcdz,ce到高阻态时间，280ns
for (uint8_t i = 0; i < 20; i++);
return data;
}
void ds1302_single_write(uint8_t addr, uint8_t data)
{
uint8_t cmd = 0;
cmd = (1 << 7) | (addr << 1);
/*
* 初始化ce和clk状态
*/
gpio_set(DS1302_CE_PINX, 0);
for (uint8_t i = 0; i < 50; i++);
gpio_set(DS1302_CLK_PINX, 0);
for (uint8_t i = 0; i < 50; i++);
gpio_set(DS1302_CE_PINX, 1);
// 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 ds1302_set_time(calendar_info *cal)
{
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));
ds1302_single_write(2, cal->hour % 10 + (cal->hour / 10 << 4));
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;
}
void ds1302_read_time(calendar_info *cal)
{
uint8_t rval;
rval = ds1302_single_read(0);
cal->sec = (rval & 0x0f) + ((rval & 0x70) >> 4) * 10;
rval = ds1302_single_read(1);
cal->min = (rval & 0x0f) + ((rval & 0x70) >> 4) * 10;
rval = ds1302_single_read(2);
cal->hour = (rval & 0x0f) + ((rval & 0x30) >> 4) * 10;
rval = ds1302_single_read(3);
cal->mday = (rval & 0x0f) + ((rval & 0x30) >> 4) * 10;
rval = ds1302_single_read(4);
cal->month = (rval & 0x0f) + ((rval & 0x10) >> 4) * 10;
rval = ds1302_single_read(5);
cal->wday = rval & 0x07;
rval = ds1302_single_read(6);
cal->year = (rval & 0x0f) + ((rval & 0xf0) >> 4) * 10 + 2000;
return;
}
void ds1302_init(void)
{
//gpio_Interrupt_init(DS1302_CE_PINX, GPO, GPI_DISAB);
//gpio_Interrupt_init(DS1302_CLK_PINX, GPO, GPI_DISAB);
gpio_init(DS1302_CE_PINX, 1, 0);
gpio_init(DS1302_CLK_PINX, 1, 0);
gpio_Interrupt_init(DS1302_IO_PINX, GPI_UP_PF, GPI_DISAB);
ds1302_single_write(7, 0x00);
if ((ds1302_single_read(0) & 0x80) == 1)
{
calendar_info sys_cal = { 0, 1, 2, 3, 4, 2012, 0, 1 };
ds1302_set_time(&sys_cal);
}
return;
}
/*
* 这个函数需要按所需的时间精度来定时调用
*/
void maintain_system_time(void)
{
enter_critical();
ds1302_read_time(&system_time);
exit_critical();
return;
}
calendar_info get_system_time(void)
{
return system_time;
}
/*************************************************************/
uint32_t calendar_to_sec(calendar_info *cal)
{
uint32_t sec = cal->sec;
uint32_t year = cal->year;
uint32_t month = cal->month;
if (year < START_YEAR || year > (START_YEAR + 135))
return 0;
sec += (uint32_t)cal->min * 60;
sec += (uint32_t)cal->hour * 3600;
sec += (uint32_t)(cal->mday - 1) * SEC_IN_DAY;
if (is_leapyear(year))
{
while (month > 1)
{
sec += (uint32_t)day_leap[--month] * SEC_IN_DAY;
}
}
else
{
while (month > 1)
{
sec += (uint32_t)day_noleap[--month] * SEC_IN_DAY;
}
}
while (year > START_YEAR)
{
sec += (uint32_t)DAY_IN_YEAR(--year) * SEC_IN_DAY;
}
return sec;
}
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;
}
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;
}
/*
* pm_time.c - 时间处理
*/
#include "gpio.h"
#include "include/pm_time.h"
#include "include/config.h"
// 被维护的系统时间
static calendar_info system_time;
#define DAY_IN_YEAR(nyear) (is_leapyear(nyear) ? 366 : 365)
static const uint8_t day_leap[] = {
0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
};
static const uint8_t day_noleap[] = {
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);
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);
/**
* ds1302_init() - ds1302的初始化
*
* 包括io的初始化以及当ds1302掉电时对其时间值设置初始值
*/
void ds1302_init(void)
{
//gpio_Interrupt_init(DS1302_CE_PINX, GPO, GPI_DISAB);
//gpio_Interrupt_init(DS1302_CLK_PINX, GPO, GPI_DISAB);
gpio_init(DS1302_CE_PINX, 1, 0);
gpio_init(DS1302_CLK_PINX, 1, 0);
gpio_Interrupt_init(DS1302_IO_PINX, GPI_UP_PF, GPI_DISAB);
// 使能写
ds1302_single_write(7, 0x00);
// 当ds1302掉电时设置时间初始值
if ((ds1302_single_read(0) & 0x80) == 1)
{
calendar_info sys_cal = { 0, 1, 2, 3, 4, 2012, 0, 1 };
ds1302_set_time(&sys_cal);
}
return;
}
/**
* is_leapyear() - 判断是否为闰年
* @year: 要判断的年份
*
* 是闰年返回1，不是闰年返回0
*/
uint8_t is_leapyear(uint16_t year)
{
return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
}
/**
* get_month_days() - 得到给定年份和月份时对应月份的天数
* @year: 给定年份
* @month: 给定月份
*
* 返回值为对应的月份的天数
*/
uint8_t get_month_days(uint16_t year, uint8_t month)
{
switch (month)
{
case 4:
case 6:
case 9:
case 11:
return 30;
case 2:
if (is_leapyear(year))
return 29;
else
return 28;
default:
return 31;
}
}
/**
* ds1302_byte_write() - 向ds1302写入一个字节
* @data: 要写入的字节
*/
static void ds1302_byte_write(uint8_t data)
{
gpio_init(DS1302_IO_PINX, 1, 0);
for (uint8_t mask = 0x01; mask != 0; mask <<= 1)
{
gpio_set(DS1302_CLK_PINX, 0);
if (data & mask)
{
gpio_set(DS1302_IO_PINX, 1);
}
else
{
gpio_set(DS1302_IO_PINX, 0);
}
// tdc,200ns,数据建立时间,tcl,1000ns,sclk低电平保持时间
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++);
}
return;
}
/**
* ds1302_byte_read() - 从ds1302读取一个字节
*
* 返回读取到的字节
*/
static uint8_t ds1302_byte_read(void)
{
uint8_t data = 0;
//gpio_init(DS1302_IO_PINX, 0, 1);
gpio_Interrupt_init(DS1302_IO_PINX, GPI_UP_PF, GPI_DISAB);
gpio_set(DS1302_CLK_PINX, 1);
// tccz,280ns,sclk到高阻态
for (uint8_t i = 0; i < 50; i++);
for (uint8_t mask = 0x01; mask != 0; mask <<= 1)
{
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))
{
data |= mask;
}
gpio_set(DS1302_CLK_PINX, 1);
// tccz,280ns,sclk到高阻态
for (uint8_t i = 0; i < 50; i++);
}
return data;
}
/**
* ds1302_single_read() - ds1302在单字节模式下读取一个地址上的数据
* @addr: 要读取的地址
*
* 返回读取的到的字节值
*/
static uint8_t ds1302_single_read(uint8_t addr)
{
uint8_t cmd = 0,
data = 0;
cmd = (1 << 7) | (addr << 1) | 1;
/*
* 初始化ce和clk状态
*/
gpio_set(DS1302_CE_PINX, 0);
for (uint8_t i = 0; i < 50; i++);
gpio_set(DS1302_CLK_PINX, 0);
for (uint8_t i = 0; i < 50; i++);
gpio_set(DS1302_CE_PINX, 1);
// tcc,ce到时钟建立时间，4us
for (uint8_t i = 0; i < 200; i++);
ds1302_byte_write(cmd);
data = ds1302_byte_read();
gpio_set(DS1302_CE_PINX, 0);
// tcdz,ce到高阻态时间，280ns
for (uint8_t i = 0; i < 20; i++);
return data;
}
/**
* ds1302_single_write() - 在单字节模式下向ds1302的一个地址上写入一个字节的数据
* @addr: 要写入数据的地址
* @data: 要写入的数据
*/
void ds1302_single_write(uint8_t addr, uint8_t data)
{
uint8_t cmd = 0;
cmd = (1 << 7) | (addr << 1);
/*
* 初始化ce和clk状态
*/
gpio_set(DS1302_CE_PINX, 0);
for (uint8_t i = 0; i < 50; i++);
gpio_set(DS1302_CLK_PINX, 0);
for (uint8_t i = 0; i < 50; i++);
gpio_set(DS1302_CE_PINX, 1);
// 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;
}
/**
* ds1302_set_time() - 向ds1302中写入时间
* @cal: 要写入的时间值地址
*/
void ds1302_set_time(calendar_info *cal)
{
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));
ds1302_single_write(2, cal->hour % 10 + (cal->hour / 10 << 4));
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;
}
/**
* ds1302_read_time() - 从ds1302中读取时间
* @cal: 读取的时间值被存放的地址
*/
void ds1302_read_time(calendar_info *cal)
{
uint8_t rval;
rval = ds1302_single_read(0);
cal->sec = (rval & 0x0f) + ((rval & 0x70) >> 4) * 10;
rval = ds1302_single_read(1);
cal->min = (rval & 0x0f) + ((rval & 0x70) >> 4) * 10;
rval = ds1302_single_read(2);
cal->hour = (rval & 0x0f) + ((rval & 0x30) >> 4) * 10;
rval = ds1302_single_read(3);
cal->mday = (rval & 0x0f) + ((rval & 0x30) >> 4) * 10;
rval = ds1302_single_read(4);
cal->month = (rval & 0x0f) + ((rval & 0x10) >> 4) * 10;
rval = ds1302_single_read(5);
cal->wday = rval & 0x07;
rval = ds1302_single_read(6);
cal->year = (rval & 0x0f) + ((rval & 0xf0) >> 4) * 10 + 2000;
return;
}
/**
* maintain_system_time() - 设置系统时间变量
*
* 这个函数需要按所需的时间精度来定时调用
*/
void maintain_system_time(void)
{
enter_critical();
ds1302_read_time(&system_time);
exit_critical();
return;
}
/**
* get_system_time() - 返回系统时间
*/
calendar_info get_system_time(void)
{
return system_time;
}
/**
* calendar_to_sec() - 分解时间到日历时间的转换
* @cal: 被转换的分解时间
*
* 返回的是日历时间，即从某一个时间点到当前转换时间所经过的秒数
*/
uint32_t calendar_to_sec(calendar_info *cal)
{
uint32_t sec = cal->sec;
uint32_t year = cal->year;
uint32_t month = cal->month;
if (year < START_YEAR || year > (START_YEAR + 135))
return 0;
sec += (uint32_t)cal->min * 60;
sec += (uint32_t)cal->hour * 3600;
sec += (uint32_t)(cal->mday - 1) * SEC_IN_DAY;
if (is_leapyear(year))
{
while (month > 1)
{
sec += (uint32_t)day_leap[--month] * SEC_IN_DAY;
}
}
else
{
while (month > 1)
{
sec += (uint32_t)day_noleap[--month] * SEC_IN_DAY;
}
}
while (year > START_YEAR)
{
sec += (uint32_t)DAY_IN_YEAR(--year) * SEC_IN_DAY;
}
return sec;
}
/**
* sec_to_calendar() - 日历时间到分解时间的转换
* @cal: 被转换的日历时间
*
* 返回的是分解时间，即以年月日时分秒形式表示的时间
*/
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 - 实现一个模拟定时器
*/
#include "include.h"
#include "include/simulat_timer.h"
#include "include/config.h"
#include "include/key.h"
static volatile st_register st_r[SIMULAT_TIMER_NUM];
/*
* st_init() - 初始化实现模拟定时器所需的pit定时器
*
* 基础定时为1ms
*/
void st_base_init(void)
{
uint32_t cnt;
cnt = bus_clk_khz * 1;
pit_init(SIMULAT_TIMER_PITX, cnt); // 1ms硬件定时中断周期
return;
}
/*
* st_init() - 初始化一个给定编号的模拟定时器
* @n: 定时器编号
* @st_m: 定时模式
* @cmr_v: 定时器比较值，在非比较模式可以为任意值
*
* 这个函数返回0表示正常完成了初始化任务，返回~0表示定时器已打开或不存在
*/
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)
{
return ~0;
}
st_r[n].flag.ten = 1;
switch(st_m)
{
case COMPARE:
st_r[n].flag.tfc = 1;
st_r[n].cmr = cmr_v;
break;
case NO_COMPARE:
st_r[n].flag.tfc = 0;
break;
default:
break;
}
return 0;
}
/*
* st_close() - 关闭一个给定编号的模拟定时器
* @n: 定时器编号
*/
void st_close(uint8_t n)
{
st_r[n].flag.ten = 0;
return;
}
/*
* st_tcf() - 查询tcf位返回
* @n: 定时器编号
*
* 这个函数在没有过比较值的时候返回0，已过比较值得时候返回1，对于不存在或未打开
*/
uint8_t st_tcf(uint8_t n)
{
uint8_t temp;
if (st_r[n].flag.tcf == 1)
{
st_r[n].flag.tcf = 0;
temp = 1;
}
else
{
temp = 0;
}
return temp;
}
/*
* st_tov() - 查询tov位返回
* @n: 定时器编号
*
* 这个函数在没有溢出时返回0，没有溢出时返回1，对于不存在或未打开
*/
uint8_t st_tov(uint8_t n)
{
uint8_t temp;
if (st_r[n].flag.tov == 1)
{
st_r[n].flag.tov = 0;
temp = 1;
}
else
{
temp = 0;
}
return temp;
}
/*
* st_count() - 查询当前模拟定时值
* @n: 定时器编号
*
* 对于不存在或未打开
*/
uint32_t st_count(uint8_t n)
{
return st_r[n].count;
}
/*
* st_base() -定时调用以模拟N路定时器
*
* 定时的最小间隔等于这个函数被调用的周期
*/
void st_base(void)
{
uint8_t i;
for (i = 0; i < SIMULAT_TIMER_NUM; i++)
{
if (st_r[i].flag.ten == 1) // 使能
{
if (++st_r[i].count == 0) // 溢出
{
st_r[i].flag.tov = 1;
} // 溢出
if (st_r[i].flag.tfc == 1) // 比较
{
if (st_r[i].count == st_r[i].cmr)
{
st_r[i].count = 0;
st_r[i].flag.tcf = 1;
}
} // 比较
} // 使能
}
if (st_tcf(0) == 1)
{
key_detect();
}
return;
}
/*
* simulat_timer.h - 实现一个模拟定时器
*/
#include "include.h"
#include "include/config.h"
#include "include/key.h"
#include "include/simulat_timer.h"
static volatile st_register st_r[SIMULAT_TIMER_NUM];
/**
* st_init() - 初始化实现模拟定时器所需的pit定时器
*
* 基础定时为1ms
*/
void st_base_init(void)
{
uint32_t cnt;
cnt = bus_clk_khz * 1;
pit_init(SIMULAT_TIMER_PITX, cnt); // 1ms硬件定时中断周期
return;
}
/**
* st_init() - 初始化一个给定编号的模拟定时器
* @n: 定时器编号
* @st_m: 定时模式
* @cmr_v: 定时器比较值，在非比较模式可以为任意值
*
* 这个函数返回0表示正常完成了初始化任务，返回~0表示定时器已打开或不存在
*/
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)
{
return ~0;
}
st_r[n].flag.ten = 1;
switch(st_m)
{
case COMPARE:
st_r[n].flag.tfc = 1;
st_r[n].cmr = cmr_v;
break;
case NO_COMPARE:
st_r[n].flag.tfc = 0;
break;
default:
break;
}
return 0;
}
/**
* st_close() - 关闭一个给定编号的模拟定时器
* @n: 定时器编号
*/
void st_close(uint8_t n)
{
st_r[n].flag.ten = 0;
return;
}
/**
* st_tcf() - 查询tcf位返回
* @n: 定时器编号
*
* 这个函数在没有过比较值的时候返回0，已过比较值得时候返回1，对于不存在或未打开
*/
uint8_t st_tcf(uint8_t n)
{
uint8_t temp;
if (st_r[n].flag.tcf == 1)
{
st_r[n].flag.tcf = 0;
temp = 1;
}
else
{
temp = 0;
}
return temp;
}
/**
* st_tov() - 查询tov位返回
* @n: 定时器编号
*
* 这个函数在没有溢出时返回0，没有溢出时返回1，对于不存在或未打开
*/
uint8_t st_tov(uint8_t n)
{
uint8_t temp;
if (st_r[n].flag.tov == 1)
{
st_r[n].flag.tov = 0;
temp = 1;
}
else
{
temp = 0;
}
return temp;
}
/**
* st_count() - 查询当前模拟定时值
* @n: 定时器编号
*
* 对于不存在或未打开
*/
uint32_t st_count(uint8_t n)
{
return st_r[n].count;
}
/**
* st_base() -定时调用以模拟N路定时器
*
* 定时的最小间隔等于这个函数被调用的周期
*/
void st_base(void)
{
uint8_t i;
for (i = 0; i < SIMULAT_TIMER_NUM; i++)
{
if (st_r[i].flag.ten == 1) // 使能
{
if (++st_r[i].count == 0) // 溢出
{
st_r[i].flag.tov = 1;
} // 溢出
if (st_r[i].flag.tfc == 1) // 比较
{
if (st_r[i].count == st_r[i].cmr)
{
st_r[i].count = 0;
st_r[i].flag.tcf = 1;
}
} // 比较
} // 使能
}
if (st_tcf(0) == 1)
{
key_detect();
}
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]
WindowPlacement=_ 125 87 1150 613 2
WindowPlacement=_ 139 121 1164 647 3