点击下载：《SAM IoT Wx v2 硬件用户指南》全文。

来源：Microchip微芯

免责声明：本文为转载文章，转载此文目的在于传递更多信息，版权归原作者所有。本文所用视频、图片、文字如涉及作品版权问题，请联系小编进行处理（联系邮箱：cathy@eetrend.com）。

typedef struct
{
    uint8_t * dst_buf;                  //指向接收缓存  
    uint8_t sfd;                        //帧首标志,为0xFF或者0xEE  
    uint8_t sfd_flag;                   //找到帧首,一般是3~5个FF或EE  
    uint8_t sfd_count;                  //帧首的个数,一般3~5个  
    uint8_t received_len;               //已经接收的字节数  
    uint8_t find_fram_flag;             //找到完整帧后,置1  
    uint8_t frame_len;                  //本帧数据总长度，这个区域是可选的  
}find_frame_struct;

/** 
* @brief    初始化寻找帧的数据结构 
* @param    p_fine_frame:指向打包帧数据结构体变量 
* @param    dst_buf:指向帧缓冲区 
* @param    sfd:帧首标志,一般为0xFF或者0xEE 
*/
void init_find_frame_struct(find_frame_struct * p_find_frame,uint8_t *dst_buf,uint8_t sfd)  
{      
    p_find_frame->dst_buf=dst_buf;      
    p_find_frame->sfd=sfd;      
    p_find_frame->find_fram_flag=0;      
    p_find_frame->frame_len=10;           
    p_find_frame->received_len=0;      
    p_find_frame->sfd_count=0;      
    p_find_frame->sfd_flag=0;  
}

/** 
* @brief    寻找一帧数据  返回处理的数据个数 
* @param    p_find_frame:指向打包帧数据结构体变量 
* @param    src_buf:指向串口接收的原始数据 
* @param    data_len:src_buf本次串口接收到的原始数据个数 
* @param    sum_len:帧缓存的最大长度 
* @return   本次处理的数据个数 
*/

uint32_t find_one_frame(find_frame_struct * p_find_frame,const uint8_t * src_buf,uint32_t data_len,uint32_t sum_len)  
{       
  uint32_t src_len=0;  
  while(data_len--)      
  {  
      if(p_find_frame ->sfd_flag==0)                                
      {   
          //没有找到起始帧首  
          if(src_buf[src_len++]==p_find_frame ->sfd)              
          {                  
              p_find_frame ->dst_buf[p_find_frame ->received_len++]=p_find_frame ->sfd;  
              if(++p_find_frame ->sfd_count==5)                          
              {                      
                  p_find_frame ->sfd_flag=1;                      
                  p_find_frame ->sfd_count=0;                      
                  p_find_frame ->frame_len=10;                  
              }              
          }  
          else            
          {                  
              p_find_frame ->sfd_count=0;                   
              p_find_frame ->received_len=0;               
          }          
      }  
      else        
      {   
          //是否是"长度"字节? Y->获取这帧的数据长度  
          if(7==p_find_frame ->received_len)                            
          {                  
              p_find_frame->frame_len=src_buf[src_len]+5+1+1+1+2; //帧首+地址号+命令号+数据长度+校验       
              if(p_find_frame->frame_len>=sum_len)                  
              {   
                  //这里处理方法根据具体应用不一定相同                      
                  MY_DEBUGF(SLAVE_DEBUG,("数据长度超出缓存!\n"));                      
                  p_find_frame->frame_len= sum_len;                       
              }              
          }             
        p_find_frame ->dst_buf[p_find_frame->received_len++]=src_buf[src_len++];                
        if(p_find_frame ->received_len==p_find_frame ->frame_len)                              
        {                  
            p_find_frame ->received_len=0;              //一帧完成                    
            p_find_frame ->sfd_flag=0;                  
            p_find_frame ->find_fram_flag=1;                   
            return src_len;              
        }          
        }      
    }      
    p_find_frame ->find_fram_flag=0;  return src_len;  
}

find_frame_struct slave_find_frame_srt;

#define SLAVE_REC_DATA_LEN  128
uint8_t slave_rec_buf[SLAVE_REC_DATA_LEN];

init_find_frame_struct(&slave_find_frame_srt,slave_rec_buf,0xEE);

find_one_frame(&slave_find_frame_srt,tmp_rec_buf,data_len,SLAVE_REC_DATA_LEN);

/*串口帧发送结构体*/
typedef struct
{
    uint16_t send_sum_len;          //要发送的帧数据长度  
    uint8_t  send_cur_len;          //当前已经发送的数据长度  
    uint8_t  send_flag;             //是否发送标志  
    uint8_t * send_data;            //指向要发送的数据缓冲区  
}uart_send_struct;

/** 
* @brief    定时发送函数,在定时器中断中调用,不使用发送中断的情况下减少发送等待 
* @param    UARTx:指向硬件串口寄存器基地址 
* @param    p:指向串口帧发送结构体变量 
*/
#define FARME_SEND_FALG 0x5A          
#define SEND_DATA_NUM   12  
static void uart_send_com(LPC_UART_TypeDef *UARTx,uart_send_struct *p)  
{      
    uint32_t i;      
    uint32_t tmp32;  

    if(UARTx->LSR &(0x01<<6))                      //发送为空      
    {         
        if(p->send_flag==FARME_SEND_FALG)          
        {                                      
            RS485ClrDE;                             // 置485为发送状态  
            tmp32=p->send_sum_len-p->send_cur_len;  
            if(tmp32>SEND_DATA_NUM)                 //向发送FIFO填充字节数据              
            {  
                for(i=0;i<SEND_DATA_NUM;i++)                  
                {                      
                    UARTx->THR=p->send_data[p->send_cur_len++];                  
                }              
            }  
            else            
            {  
                for(i=0;i<tmp32;i++)                  
                {                      
                    UARTx->THR=p->send_data[p->send_cur_len++];                  
                }                  
                p->send_flag=0;                                  
            }          
        }  
        else        
        {              
            RS485SetDE;          
        }      
    }  
}

uart_send_struct uart0_send_str;

uint8_t uart0_send_buf[UART0_SEND_LEN];

uart0_send_str.send_sum_len=data_len;      //data_len为要发送的数据长度
uart0_send_str.send_cur_len=0;             //固定为0
uart0_send_str.send_data=uart0_send_buf;   //绑定发送缓冲区
uart0_send_str.send_flag=FARME_SEND_FALG;  //设置发送标志

来源：STM32嵌入式开发

免责声明：本文为转载文章，转载此文目的在于传递更多信息，版权归原作者所有。本文所用视频、图片、文字如涉及作品版权问题，请联系小编进行处理（联系邮箱：cathy@eetrend.com）。

来源：HOLTEK

免责声明：本文为转载文章，转载此文目的在于传递更多信息，版权归原作者所有。本文所用视频、图片、文字如涉及作品版权问题，请联系小编进行处理（联系邮箱：cathy@eetrend.com）。

大家好，今天分享一篇关于按键处理的文章，项目地址如下https://gitee.com/wei513723/key_board 

key_board介绍

key_board用于单片机中的小巧多功能按键支持，软件采用了分层的思想，并且做到了与平台无关，用户只需要提供按键的基本信息和读写io电平的函数即可，非常方便移植，同时支持多个矩阵键盘及多个单io控制键盘。

目前已实现按下触发、弹起触发、长按自动触发、长按弹起触发、多击触发、连续触发等功能，并且能够随意组合（支持状态的同一时间轴和非同一时间轴），后续还会添加更多的功能。

使用说明

1. 初始化相关的硬件资源。

2. 提供一个1ms的定时器，用于周期性的调用'key_check'函数。

3. 提供按键的描述及读写io的函数。

4. 将键盘注册到系统。

5. 具体的操作参考提供的stm32例程。

6. 因为程序默认使用了堆内存，当发现程序运行结果不正常时，尝试增大你的程序堆空间，或者注册调试接口查看原因。

7. 更详细的使用教程见详细使用说明或者提供的stm32例程。

已支持的键盘

1、矩阵键盘

矩阵键盘

2、单io按键

单io按键

详细使用说明

将key_board.c，key_board.h，key_board_config.h放进key_board文件夹中并包含进你的工程，添加头文件路径。

基础功能移植（以stm32矩阵键盘为例）

首先需要一个可使用的定时器（如果不想使用定时器也可直接放到主循环中，但不推荐，会导致时基不准确），固定为1ms触发一次；

准备待检测的按键的基本信息，可参考key_board_sample.c文件中的struct key_pin_t结构体，如：

struct key_pin_t {
    GPIO_TypeDef *port;     //按键端口号
    uint16_t pin;           //按键的引脚号
    GPIO_PinState valid;    //按键的有效电平（即按键按下时的电平）
    GPIO_PinState invalid;  //按键的无效电平（即按键空闲时的电平）
    /*
    可添加你的其它参数
    */
};

定义待检测的按键信息，可参考key_board_sample.c文件中的const struct key_pin_t key_pin_sig[]结构体数组，对应头文件为key_board_sample.h，如：

//全局变量
const struct key_pin_t key_pin_sig[] = {
    {
        .port = KEY_PORT_J12,
        .pin = KEY_PIN_J12,
        .valid = KEY_PRESS_LEVEL_J12,
        .invalid = KEY_RELEASE_LEVEL_J12
    },
    {
        .port = KEY_PORT_J34,
        .pin = KEY_PIN_J34,
        .valid = KEY_PRESS_LEVEL_J34,
        .invalid = KEY_RELEASE_LEVEL_J34
    },
    {
        .port = KEY_PORT_J56,
        .pin = KEY_PIN_J56,
        .valid = KEY_PRESS_LEVEL_J56,
        .invalid = KEY_RELEASE_LEVEL_J56
    },
};

如果为矩阵键盘还需要定义控制io的相关信息，可参考key_board_sample.c文件中的const struct key_pin_t key_pin_ctrl[]结构体数组，对应头文件为key_board_sample.h，如：

const struct key_pin_t key_pin_ctrl[] = {
    {
        .port = KEY_PORT_J135,
        .pin = KEY_PIN_J135,
        .valid = KEY_CTL_LINE_ENABLE,
        .invalid = KEY_CTL_LINE_DISABLE
    },
    {
        .port = KEY_PORT_J246,
        .pin = KEY_PIN_J246,
        .valid = KEY_CTL_LINE_ENABLE,
        .invalid = KEY_CTL_LINE_DISABLE
    },
};

实现按键io的电平读取函数，可参考key_board_sample.c文件中的pin_level_get函数，如：

static inline bool pin_level_get(const void *desc)
{
    struct key_pin_t *pdesc;

    pdesc = (struct key_pin_t *)desc;
    return HAL_GPIO_ReadPin(pdesc->port, pdesc->pin) == pdesc->valid;
}

如果为矩阵键盘还需要实现按键io的电平写入函数，可参考key_board_sample.c文件中的pin_level_set函数，如：

static inline void pin_level_set(const void *desc, bool flag)
{
    struct key_pin_t *pdesc;

    pdesc = (struct key_pin_t *)desc;
    HAL_GPIO_WritePin(pdesc->port, pdesc->pin, flag ? pdesc->valid : pdesc->invalid);
}

定义按键的id及功能结构体struct key_public_sig_t，可参考key_board_sample.c文件中的const struct key_public_sig_t key_public_sig[]结构体数组，对应头文件key_board.h，如：

const struct key_public_sig_t key_public_sig[] = {
    KEY_PUBLIC_SIG_DEF(KEY_UP, &key_pin_sig[0], pin_level_get, KEY_FLAG_NONE),
    KEY_PUBLIC_SIG_DEF(KEY_LEFT, &key_pin_sig[1], pin_level_get, KEY_FLAG_NONE),
    KEY_PUBLIC_SIG_DEF(KEY_DOWN, &key_pin_sig[2], pin_level_get, KEY_FLAG_NONE),
    //下面的是因为使用的矩阵键盘而扩展出来的三个按键
    KEY_PUBLIC_SIG_DEF(KEY_ENTER, &key_pin_sig[0], pin_level_get, KEY_FLAG_NONE),
    KEY_PUBLIC_SIG_DEF(KEY_RIGHT, &key_pin_sig[1], pin_level_get, KEY_FLAG_NONE),
    KEY_PUBLIC_SIG_DEF(KEY_EXIT, &key_pin_sig[2], pin_level_get, KEY_FLAG_NONE),
};

如果为矩阵键盘还需要定义控制io的id及功能结构体struct key_public_ctrl_t，可参考key_board_sample.c文件中的const struct key_public_ctrl_t key_public_ctrl[]结构体数组，对应头文件key_board.h，如：

const struct key_public_ctrl_t key_public_ctrl[] = {
    KEY_PUBLIC_CTRL_DEF(&key_pin_ctrl[0], pin_level_set),
    KEY_PUBLIC_CTRL_DEF(&key_pin_ctrl[1], pin_level_set),
};

初始化键盘，可参考key_board_sample.c文件中的GPIO_Key_Board_Init函数，如：

void GPIO_Key_Board_Init(void)
{
    //硬件io的初始化
    GPIO_InitTypeDef GPIO_InitStruct;
    unsigned int i;

    RCC_KEY_BOARD_CLK_ENABLE();

    GPIO_InitStruct.Pull  = GPIO_PULLUP;
    GPIO_InitStruct.Mode  = GPIO_MODE_INPUT;
    for(i = 0;i < ARRAY_SIZE(key_pin_sig);i++)
    {
        GPIO_InitStruct.Pin   = key_pin_sig[i].pin;
        HAL_GPIO_Init(key_pin_sig[i].port, &GPIO_InitStruct);
    }

    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    GPIO_InitStruct.Pull  = GPIO_NOPULL;
    GPIO_InitStruct.Mode  = GPIO_MODE_OUTPUT_PP;
    for(i = 0;i < ARRAY_SIZE(key_pin_ctrl);i++)
    {
        GPIO_InitStruct.Pin   = key_pin_ctrl[i].pin;
        HAL_GPIO_Init(key_pin_ctrl[i].port, &GPIO_InitStruct);
    }

    //初始化键盘
    key_board_init();
    //注册键盘到系统中（矩阵键盘）
    key_board_register(KEY_BOARD_MATRIX, key_public_sig, ARRAY_SIZE(key_public_sig), key_public_ctrl, ARRAY_SIZE(key_public_ctrl));
}

主流程伪代码框架，更多例子参考main_test.c文件：

int main(void)
{
    //初始化硬件io，并注册键盘
    GPIO_Key_Board_Init();
    //初始化定时器，用于按键扫描（1ms）
    init_tmr();

    for(;;)
    {
        if(key_check_state(KEY_UP, KEY_RELEASE))
        {
            PRINTF("KEY_UP KEY_RELEASE\r\n");
        }
        if(key_check_state(KEY_UP, KEY_PRESS))
        {
            PRINTF("KEY_UP KEY_PRESS\r\n");
        }
    }
}

//定时器到期回调处理函数
void tmr_irq_callback(void)
{
    //调用按键扫描核心函数
    key_check();
}

扩展功能长按的使用

首先确保key_board_config.h文件中宏KEY_LONG_SUPPORT已处于使能状态，并且正确设置了宏KEY_DEFAULT_LONG_TRRIGER_TIME的值；

设置按键功能需要对长按进行检测，如：

KEY_PUBLIC_SIG_DEF(KEY_UP, &key_pin_sig[0], pin_level_get, KEY_FLAG_PRESS_LONG | KEY_FLAG_RELEASE_LONG)

使用例程：

if(key_check_state(KEY_UP, KEY_PRESS_LONG))
{
    PRINTF("KEY_UP KEY_PRESS_LONG\r\n");
}
if(key_check_state(KEY_UP, KEY_RELEASE_LONG))
{
    PRINTF("KEY_UP KEY_RELEASE_LONG\r\n");
}

扩展功能连按的使用

首先确保key_board_config.h文件中宏KEY_CONTINUOUS_SUPPORT已处于使能状态，并且正确设置了宏KEY_DEFAULT_CONTINUOUS_INIT_TRRIGER_TIME和KEY_DEFAULT_CONTINUOUS_PERIOD_TRRIGER_TIME的值；

设置按键功能需要对连按进行检测，如：

KEY_PUBLIC_SIG_DEF(KEY_UP, &key_pin_sig[0], pin_level_get, KEY_FLAG_PRESS_CONTINUOUS)

使用例程：

if(key_check_state(KEY_UP, KEY_PRESS_CONTINUOUS))
{
    PRINTF("KEY_UP KEY_PRESS_CONTINUOUS\r\n");
}

扩展功能多击的使用

首先确保key_board_config.h文件中宏KEY_MULTI_SUPPORT已处于使能状态，并且正确设置了宏KEY_DEFAULT_MULTI_INTERVAL_TIME的值；

设置按键功能需要多击进行检测，如：

KEY_PUBLIC_SIG_DEF(KEY_UP, &key_pin_sig[0], pin_level_get, KEY_FLAG_PRESS_MULTI | KEY_FLAG_RELEASE_MULTI)

使用例程：

unsigned int res;
res = key_check_state(KEY_UP, KEY_PRESS_MULTI);
if(res)
{
    PRINTF("KEY_UP KEY_PRESS_MULTI:%d\r\n", res);
}
res = key_check_state(KEY_UP, KEY_RELEASE_MULTI);
if(res)
{
    PRINTF("KEY_UP KEY_RELEASE_MULTI:%d\r\n", res);
}

扩展功能组合状态（同一时间轴）

使用例程：

unsigned int key_down_release_long, key_up_release_long;
key_down_release_long = key_check_state(KEY_DOWN, KEY_RELEASE_LONG);
key_up_release_long = key_check_state(KEY_UP, KEY_RELEASE_LONG);
if(key_down_release_long && key_up_release_long)
{
    PRINTF("KEY_DOWN KEY_RELEASE_LONG && KEY_UP KEY_RELEASE_LONG\n");
}

扩展功能组合状态（非同一时间轴）

首先确保key_board_config.h文件中宏KEY_COMBINE_SUPPORT已处于使能状态，并且正确设置了宏KEY_DEFAULT_COMBINE_INTERVAL_TIME的值；

使用例程：

//用于保存注册后的组合状态id
static unsigned int test_id1, test_id2;

//定义要检测的状态
const struct key_combine_t test_combine1[] = {
    { .id = KEY_UP,     .state = KEY_PRESS },
    { .id = KEY_DOWN,   .state = KEY_PRESS_LONG },
    { .id = KEY_UP,     .state = KEY_PRESS },
};
//注册组合状态
test_id1 = key_combine_register(test_combine1, ARRAY_SIZE(test_combine1));

const struct key_combine_t test_combine2[] = {
    { .id = KEY_UP,     .state = KEY_PRESS },
    { .id = KEY_DOWN,   .state = KEY_PRESS },
    { .id = KEY_UP,     .state = KEY_PRESS },
    { .id = KEY_DOWN,   .state = KEY_PRESS },
};
test_id2 = key_combine_register(test_combine2, ARRAY_SIZE(test_combine2));

if(key_check_combine_state(test_id1))
{
    PRINTF("combine test_id1\r\n");
}

if(key_check_combine_state(test_id2))
{
    PRINTF("combine test_id2\r\n");
}

原文：https://gitee.com/wei513723/key_board

直接转载来源：嵌入式电子

免责声明：本文为转载文章，转载此文目的在于传递更多信息，版权归原作者所有。本文所用视频、图片、文字如涉及作品版权问题，请联系小编进行处理（联系邮箱：cathy@eetrend.com）。

系统设计人员在为产品添加蓝牙功能时面临诸多障碍，从技术和资源限制到预算限制，从上市时间压力到具有挑战性的性能和集成要求。Microchip Technology Inc.（微芯科技公司）扩大旗下蓝牙低功耗产品组合，推出12 种新产品，旨在为设计人员提供广泛的选择，以帮助其应对独特的挑战，克服从最简单到最高级设计中的各类障碍。这些新增产品包括可直接用于射频应用的WBZ350模块和PIC32CX-BZ3 SoC，为在产品设计中集成蓝牙低功耗单片机（MCU）提供了最低的门槛。如需了解全部12款产品，请访问Microchip蓝牙低功耗网页：https://www.microchip.com/en-us/products/wireless-connectivity/bluetooth...

Microchip负责无线解决方案事业部的副总裁Rishi Vasuki 表示：“在任何类型的产品中添加蓝牙功能时，选择越来越重要。开发人员需要各种选项，并能根据自身技能和应用需求在不同选项之间进行切换。没有其他供应商生产的蓝牙低功耗产品能像我们的即插即用模块一样简单易用，也无法为更先进的设计提供如此广泛的选项，所有选项都来自同一家供应商，从而不必以功能换取简单易用或以创新牺牲快速开发。” 

除蓝牙MCU外，Microchip还推出了RNBD350即插即用模块，降低了在产品设计中添加蓝牙低功耗连接的成本和复杂性障碍。这些模块最大限度地减少了射频设计优化、法规认证和软件开发所需的时间、资金和工程资源。对于希望获得更大灵活性的资深工程师，Microchip 可提供强大的无线、多协议MCU片上系统 （SoC）选项。 

Microchip蓝牙低功耗器件的应用示例包括物联网智能家居和楼宇系统、工业物联网（IIoT）解决方案和汽车设计。设计人员在入门级应用中使用新扩展的蓝牙低功耗产品组合，可受益于简便的开发流程，包括内部支持服务和开发工具，而不会影响蓝牙功能。此外，Microchip全面的MCU专业知识还能帮助他们进行产品选择，在需要应对更复杂的设计挑战时，还可以轻松切换到更先进的工业级蓝牙低功耗产品。 

开发人员还可以利用Microchip不断扩大的无线产品组合来实现端到端解决方案。这些产品组合提供一系列采用Wi-Fi®、Zigbee®、Thread 和sub-GHz等流行无线技术的产品，可与蓝牙产品组合无缝协作。 

开发工具

Microchip为客户提供全面的开发工具、软件以及iOS®和Android®平台移动应用程序源代码、构建模块应用示例和演示，以及免费的设计检查服务，帮助客户快速启动产品开发。

供货与定价

如需了解更多信息或购买，请联系Microchip销售代表、全球授权分销商或访问Microchip采购和客户服务网站 www.microchipdirect.com。

来源：Microchip微芯

免责声明：本文为转载文章，转载此文目的在于传递更多信息，版权归原作者所有。本文所用视频、图片、文字如涉及作品版权问题，请联系小编进行处理（联系邮箱：cathy@eetrend.com）。