智能车菜单编写(2)

我所采用的菜单是基于一个开源的按键组件，感兴趣的同学可以先去了解一下

开源按键组件MultiButton支持菜单操作(事件驱动型)

第1期 | MultiButton，一个小巧简单易用的事件驱动型按键驱动模块

该组件的优点在于可以无限的扩容按键的使用，且该菜单简洁易懂，看不懂的同学可以直接移植到对应的单片机上，然后一个一个更改参数来慢慢理解。具体的原理实现就不细讲，主要讲如何使用。

首先将multi_button.c和multi_button.h文件复制到工程目录中

multi_button.c

/*
 * Copyright (c) 2016 Zibin Zheng 
 * All rights reserved
 */
 
#include "multi_button.h"
#include "headfile.h"
 
#define EVENT_CB(ev)   if(handle->cb[ev])handle->cb[ev]((Button*)handle)
 
//button handle list head.
static struct Button* head_handle = NULL;
 
/**
  * @brief  Initializes the button struct handle.
  * @param  handle: the button handle strcut.
  * @param  pin_level: read the HAL GPIO of the connet button level.
  * @param  active_level: pressed GPIO level.
  * @retval None
  */
void button_init(struct Button* handle, uint8_t(*pin_level)(), uint8_t active_level)
{
	memset(handle, 0, sizeof(struct Button));
	handle->event = (uint8_t)NONE_PRESS;
	handle->hal_button_Level = pin_level;
	handle->button_level = handle->hal_button_Level();
	handle->active_level = active_level;
}
 
/**
  * @brief  Attach the button event callback function.
  * @param  handle: the button handle strcut.
  * @param  event: trigger event type.
  * @param  cb: callback function.
  * @retval None
  */
void button_attach(struct Button* handle, PressEvent event, BtnCallback cb)
{
	handle->cb[event] = cb;
}
 
/**
  * @brief  Inquire the button event happen.
  * @param  handle: the button handle strcut.
  * @retval button event.
  */
PressEvent get_button_event(struct Button* handle)
{
	return (PressEvent)(handle->event);
}
 
/**
  * @brief  Button driver core function, driver state machine.
  * @param  handle: the button handle strcut.
  * @retval None
  */
void button_handler(struct Button* handle)
{
	uint8_t read_gpio_level = handle->hal_button_Level();
 
	//ticks counter working..
	if((handle->state) > 0) handle->ticks++;
 
	/*------------button debounce handle---------------*/
	if(read_gpio_level != handle->button_level) { //not equal to prev one
		//continue read 3 times same new level change
		if(++(handle->debounce_cnt) >= DEBOUNCE_TICKS) {
			handle->button_level = read_gpio_level;
			handle->debounce_cnt = 0;
		}
	} else { //leved not change ,counter reset.
		handle->debounce_cnt = 0;
	}
 
	/*-----------------State machine-------------------*/
	switch (handle->state) {
	case 0:
		if(handle->button_level == handle->active_level) {	//start press down
			handle->event = (uint8_t)PRESS_DOWN;
			EVENT_CB(PRESS_DOWN);
			handle->ticks = 0;
			handle->repeat = 1;
			handle->state = 1;
		} else {
			handle->event = (uint8_t)NONE_PRESS;
		}
		break;
 
	case 1:
		if(handle->button_level != handle->active_level) { //released press up
			handle->event = (uint8_t)PRESS_UP;
			EVENT_CB(PRESS_UP);
			handle->ticks = 0;
			handle->state = 2;
 
		} else if(handle->ticks > LONG_TICKS) {
			handle->event = (uint8_t)LONG_PRESS_START;
			EVENT_CB(LONG_PRESS_START);
			handle->state = 5;
		}
		break;
 
	case 2:
		if(handle->button_level == handle->active_level) { //press down again
			handle->event = (uint8_t)PRESS_DOWN;
			EVENT_CB(PRESS_DOWN);
			handle->repeat++;
			EVENT_CB(PRESS_REPEAT); // repeat hit
			handle->ticks = 0;
			handle->state = 3;
		} else if(handle->ticks > SHORT_TICKS) { //released timeout
			if(handle->repeat == 1) {
				handle->event = (uint8_t)SINGLE_CLICK;
				EVENT_CB(SINGLE_CLICK);
			} else if(handle->repeat == 2) {
				handle->event = (uint8_t)DOUBLE_CLICK;
				EVENT_CB(DOUBLE_CLICK); // repeat hit
			}
			handle->state = 0;
		}
		break;
 
	case 3:
		if(handle->button_level != handle->active_level) { //released press up
			handle->event = (uint8_t)PRESS_UP;
			EVENT_CB(PRESS_UP);
			if(handle->ticks < SHORT_TICKS) {
				handle->ticks = 0;
				handle->state = 2; //repeat press
			} else {
				handle->state = 0;
			}
		}
		break;
 
	case 5:
		if(handle->button_level == handle->active_level) {
			//continue hold trigger
			handle->event = (uint8_t)LONG_PRESS_HOLD;
			EVENT_CB(LONG_PRESS_HOLD);
 
		} else { //releasd
			handle->event = (uint8_t)PRESS_UP;
			EVENT_CB(PRESS_UP);
			handle->state = 0; //reset
		}
		break;
	}
}
 
/**
  * @brief  Start the button work, add the handle into work list.
  * @param  handle: target handle strcut.
  * @retval 0: succeed. -1: already exist.
  */
int button_start(struct Button* handle)
{
	struct Button* target = head_handle;
	while(target) {
		if(target == handle) return -1;	//already exist.
		target = target->next;
	}
	handle->next = head_handle;
	head_handle = handle;
	return 0;
}
 
/**
  * @brief  Stop the button work, remove the handle off work list.
  * @param  handle: target handle strcut.
  * @retval None
  */
void button_stop(struct Button* handle)
{
	struct Button** curr;
	for(curr = &head_handle; *curr; ) {
		struct Button* entry = *curr;
		if (entry == handle) {
			*curr = entry->next;
//			free(entry);
		} else
			curr = &entry->next;
	}
}
 
/**
  * @brief  background ticks, timer repeat invoking interval 5ms.
  * @param  None.
  * @retval None
  */
void button_ticks()
{
	struct Button* target;
	for(target=head_handle; target; target=target->next) {
		button_handler(target);
	}
}
 

multi_button.h：

/*
 * Copyright (c) 2016 Zibin Zheng 
 * All rights reserved
 */
 
#ifndef _MULTI_BUTTON_H_
#define _MULTI_BUTTON_H_
 
#include 
#include 
 
//According to your need to modify the constants.
#define TICKS_INTERVAL    10	//ms
#define DEBOUNCE_TICKS    2	//MAX 8
#define SHORT_TICKS       (300 /TICKS_INTERVAL)
#define LONG_TICKS        (1000 /TICKS_INTERVAL)
 
 
typedef void (*BtnCallback)(void*);
 
typedef enum {
    PRESS_DOWN = 0,     //按键按下，每次按下都触发
    PRESS_UP,           //按键弹起，每次松开都触发
    PRESS_REPEAT,       //重复按下触发，变量repeat计数连击次数
    SINGLE_CLICK,       //单击按键事件
    DOUBLE_CLICK,       //双击按键事件
    LONG_PRESS_START,   //达到长按时间阈值时触发一次
    LONG_PRESS_HOLD,    //长按期间一直触发
    number_of_event,    //事件种类数
    NONE_PRESS
}PressEvent;
 
typedef struct Button {
    uint16_t ticks;
    uint8_t  repeat : 4;  // 记录连击次数
    uint8_t  event : 4;   // 记录具体事件
    uint8_t  state : 3;   // 下一个要跳转的状态，用于状态的切换
    uint8_t  debounce_cnt : 3;  // 记录持续次数（每次固定时间，用于去抖）
    uint8_t  active_level : 1;  // 有效电平（按键按下时的电平）
    uint8_t  button_level : 1;  // 记录当前的电平
    uint8_t  (*hal_button_Level)(void); // 函数指针（指向获取当前按键电平的函数）
    BtnCallback  cb[number_of_event];   // 函数指针数组：分别指向各个事件的回调函数
    struct Button* next;
}Button;
 
#ifdef __cplusplus
extern "C" {
#endif
 
void button_init(struct Button* handle, uint8_t(*pin_level)(), uint8_t active_level);
void button_attach(struct Button* handle, PressEvent event, BtnCallback cb);
PressEvent get_button_event(struct Button* handle);
int  button_start(struct Button* handle);
void button_stop(struct Button* handle);
void button_ticks(void);
 
#ifdef __cplusplus
}
#endif
 
#endif

最后将button_ticks（void）函数放入中断中，以用来检测按键状态。也可以放入364的另外一个核中，具体的两个核操作方式以后可能会简单介绍，因为我写的也很烂。

如上.h文件所示，每个按键都具备用按下触发，弹起触发，单击双击等模式，我之前试过可使用一个按键来实现菜单的功能，就是不停的单击双击长按会混淆每个模式所对应的函数，建议还是4个按键，大体可分两个按键负责页面的上下移动，两个按键负责进入和退出二级菜单。

移植好按键的固件，下面需要对按键进行每个按键功能的定义。与上一样，可在工程目录中新建button.c和button.h文件。

button.c：

#include "button.h"
#include "headfile.h"
 
static const PIN_enum key_pin[4] = {P22_3, P22_2, P22_1, P22_0},    //存放的是对应按键的引脚
                        dial_pin[4] = {P33_4, P33_5,P33_13,P33_12}; //存放对应拨码开关的引脚，用于之后修改菜单参数的数量级
static Button buttons[4];
 
 
IFX_INLINE static void assignments(void) {
  button_attach(&buttons[0], SINGLE_CLICK, button1_change_single);
  button_attach(&buttons[0], DOUBLE_CLICK, button1_change_double);
  button_attach(&buttons[0], LONG_PRESS_START, button1_change_long);
 //定义P22_3引脚，单击，双击，长按所对应的功能函数，即第三个参数
  button_attach(&buttons[1], SINGLE_CLICK, button2_change_single);
  button_attach(&buttons[1], DOUBLE_CLICK, button2_change_double);
  button_attach(&buttons[1], LONG_PRESS_START, button2_change_long);
    //同上
  button_attach(&buttons[2], SINGLE_CLICK, ui_key_yes_click); //同上，单击yes进入二级菜单
  button_attach(&buttons[3], SINGLE_CLICK, ui_key_no_click);  //同上，单击no退出二级菜单
}
 
uint8_t key0_read(void) {
  return gpio_get(key_pin[0]);
}
 
uint8_t key1_read(void) {
  return gpio_get(key_pin[1]);
}
 
uint8_t key2_read(void) {
  return gpio_get(key_pin[2]);
}
 
uint8_t key3_read(void) {
  return gpio_get(key_pin[3]);
}
 
uint8_t dial_read(uint8_t id) {
  return gpio_get(dial_pin[id]);
}
 
void buzzer_init(void){
  gpio_init(BEEP_PIN, GPO, 1, PUSHPULL);
}
void key_init(void) {
  button_init(&buttons[0], key0_read, 0);
  button_init(&buttons[1], key1_read, 0);
  button_init(&buttons[2], key2_read, 0);
  button_init(&buttons[3], key3_read, 0);
  assignments();
  for (int i = 0; i < 4; ++i) {
    gpio_init(key_pin[i], GPI, 0, NO_PULL);
    //gpio_init(dial_pin[i], GPI, 0, NO_PULL);
    button_start(&buttons[i]);
  }
}

button.h

#ifndef _button_H_
#define _button_H_
#include "StdIf/IfxStdIf_DPipe.h"
#include "PLATFORM_TYPES.H"
#include "common.h"
#include 
 
//#define BEEP_PIN   P33_10
#define BEEP_PIN   P10_5
#define buzzer_on  gpio_set(BEEP_PIN,0)
#define buzzer_off gpio_set(BEEP_PIN,1)
 
extern uint8 ips200_show_flag;
 
void key_init(void);
void buzzer_init();
uint8_t dial_read(uint8_t id);
 
#endif

具体的按键调用函数如下，下一章就是对菜单页进行编写。