sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Fix nxstyle issue

Browse Source 
Signed-off-by: Xiang Xiao <xiaoxiang@xiaomi.com>
This commit is contained in:
Xiang Xiao 2020-06-05 23:40:18 +08:00 committed by Abdelatif Guettouche
parent 1b47aa1cb2
commit a61b8a13c6
75 changed files with 861 additions and 803 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
boards/arm/efm32/olimex-efm32g880f128-stk/src/efm32_buttons.c
View File

@ -32,6 +32,7 @@
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/* The Olimex board has four buttons, BUT1-4. Each is grounded and so should
* have a weak pull-up so that it will be sensed as "1" when open and "0"
* when closed.

8
boards/arm/kinetis/freedom-k64f/src/k64_buttons.c
View File

@ -60,10 +60,10 @@
* low-power wake up signal.
* Also, only SW3 can be a non-maskable interrupt.
*
* Switch GPIO Function
* --------- ---------------------------------------------------------------
* SW2 PTC6/SPI0_SOUT/PD0_EXTRG/I2S0_RX_BCLK/FB_AD9/I2S0_MCLK/LLWU_P10
* SW3 PTA4/FTM0_CH1/NMI_b/LLWU_P3
* Switch GPIO Function
* -------- ---------------------------------------------------------------
* SW2 PTC6/SPI0_SOUT/PD0_EXTRG/I2S0_RX_BCLK/FB_AD9/I2S0_MCLK/LLWU_P10
* SW3 PTA4/FTM0_CH1/NMI_b/LLWU_P3
*/
/****************************************************************************

8
boards/arm/kinetis/freedom-k66f/src/k66_buttons.c
View File

@ -64,10 +64,10 @@
* low-power wake up signal.
* Also, only SW3 can be a non-maskable interrupt.
*
* Switch GPIO Function
* --------- ---------------------------------------------------------------
* SW2 PTD11/LLWU_P25/SPI2_PCS0/SDHC0_CLKIN/LPUART0_CTS/FB_A19
* SW3 PTA10/LLWU_P22/FTM2_CH0/MII0_RXD2/FTM2_QD_PHA/TPM2_CH0/TRACE_D0
* Switch GPIO Function
* -------- ---------------------------------------------------------------
* SW2 PTD11/LLWU_P25/SPI2_PCS0/SDHC0_CLKIN/LPUART0_CTS/FB_A19
* SW3 PTA10/LLWU_P22/FTM2_CH0/MII0_RXD2/FTM2_QD_PHA/TPM2_CH0/TRACE_D0
*/
/****************************************************************************

8
boards/arm/kinetis/kwikstik-k40/src/k40_buttons.c
View File

@ -59,8 +59,8 @@
*
* Description:
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state of
* all buttons or board_button_irq() may be called to register button
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/
@ -88,8 +88,8 @@ uint32_t board_buttons(void)
*
* Description:
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state of
* all buttons or board_button_irq() may be called to register button
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be

1
boards/arm/kinetis/twr-k60n512/src/k60_buttons.c
View File

@ -53,6 +53,7 @@
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
/* The TWR-K60N512 has user buttons (plus a reset button):
*
* 1. SW1 (IRQ0) PTA19

5
boards/arm/lpc17xx_40xx/lincoln60/src/lpc17_40_buttons.c
View File

@ -60,6 +60,7 @@
/****************************************************************************
* Private Data
****************************************************************************/
/* Pin configuration for each STM3210E-EVAL button. This array is indexed by
* the BUTTON_* and JOYSTICK_* definitions in board.h
*/
@ -158,8 +159,8 @@ uint32_t board_buttons(void)
*
* Description:
* board_button_initialize() must be called to initialize button resources.
* After that, board_button_irq() may be called to register button interrupt
* handlers.
* After that, board_button_irq() may be called to register button
* interrupt handlers.
*
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is

4
boards/arm/lpc17xx_40xx/lpc4088-devkit/src/lpc17_40_buttons.c
View File

@ -73,8 +73,8 @@
* JOY_D -- Connected to P2[19]
* JOY_CTR -- Connected to P0[14]
*
* The switches are all connected to ground and should be pulled up and sensed
* with a value of '0' when closed.
* The switches are all connected to ground and should be pulled up and
* sensed with a value of '0' when closed.
*/
/* Pin configuration for each LPC4088 Developer's Kit button. This array is

9
boards/arm/lpc17xx_40xx/olimex-lpc1766stk/src/lpc17_40_buttons.c
View File

@ -60,6 +60,7 @@
/****************************************************************************
* Private Data
****************************************************************************/
/* Pin configuration for each STM3210E-EVAL button. This array is indexed by
* the BUTTON_* and JOYSTICK_* definitions in board.h
*/
@ -96,8 +97,8 @@ static uint8_t g_buttonirq[NUM_BUTTONS] =
*
* Description:
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state of
* all buttons or board_button_irq() may be called to register button
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/
@ -161,8 +162,8 @@ uint32_t board_buttons(void)
*
* Description:
* board_button_initialize() must be called to initialize button resources.
* After that, board_button_irq() may be called to register button interrupt
* handlers.
* After that, board_button_irq() may be called to register button
* interrupt handlers.
*
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is

12
boards/arm/lpc17xx_40xx/open1788/src/lpc17_40_buttons.c
View File

@ -58,8 +58,8 @@
* Private Data
****************************************************************************/
/* The Open1788 supports several buttons. All will read "1" when open and "0"
* when closed
/* The Open1788 supports several buttons. All will read "1" when open and
* "0" when closed
*
* USER1 -- Connected to P4[26]
* USER2 -- Connected to P2[22]
@ -73,8 +73,8 @@
* JOY_D -- Connected to P2[19]
* JOY_CTR -- Connected to P0[14]
*
* The switches are all connected to ground and should be pulled up and sensed
* with a value of '0' when closed.
* The switches are all connected to ground and should be pulled up and
* sensed with a value of '0' when closed.
*/
/* Pin configuration for each Open1788 button. This array is indexed by
@ -108,8 +108,8 @@ static const uint8_t g_buttonirq[NUM_BUTTONS] =
*
* Description:
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state of
* all buttons or board_button_irq() may be called to register button
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/

1
boards/arm/lpc17xx_40xx/zkit-arm-1769/src/lpc17_40_buttons.c
View File

@ -67,6 +67,7 @@
/****************************************************************************
* Private Data
****************************************************************************/
/* Pin configuration for each zkit-arm-1769 button.
* This array is indexed by NUM_BUTTONS in board.h
*/

2
boards/arm/lpc43xx/bambino-200e/src/lpc43_buttons.c
View File

@ -3,7 +3,7 @@
*
* Copyright (C) 2016-2017 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
* Alan Carvalho de Assis acassis@gmail.com [nuttx] <nuttx@googlegroups.com>
* Alan Carvalho de Assis acassis@gmail.com
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions

4
boards/arm/lpc43xx/lpc4330-xplorer/src/lpc43_buttons.c
View File

@ -158,8 +158,8 @@ uint32_t board_buttons(void)
*
* Description:
* board_button_initialize() must be called to initialize button resources.
* After that, board_button_irq() may be called to register button interrupt
* handlers.
* After that, board_button_irq() may be called to register button
* interrupt handlers.
*
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released.

5
boards/arm/lpc43xx/lpc4357-evb/src/lpc43_buttons.c
View File

@ -60,6 +60,7 @@
/****************************************************************************
* Private Data
****************************************************************************/
/* Pin configuration for each LPC4357-EVB button. This array is indexed by
* the BUTTON_* definitions in board.h
*/
@ -164,8 +165,8 @@ uint32_t board_buttons(void)
*
* Description:
* board_button_initialize() must be called to initialize button resources.
* After that, board_button_irq() may be called to register button interrupt
* handlers.
* After that, board_button_irq() may be called to register button
* interrupt handlers.
*
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released.

8
boards/arm/sam34/sam3u-ek/src/sam_buttons.c
View File

@ -67,13 +67,13 @@
****************************************************************************/
#if defined(CONFIG_SAM34_GPIOA_IRQ) && defined(CONFIG_ARCH_IRQBUTTONS)
static int board_button_irqx(gpio_pinset_t pinset, int irq, xcpt_t irqhandler,
void *arg)
static int board_button_irqx(gpio_pinset_t pinset, int irq,
xcpt_t irqhandler, void *arg)
{
irqstate_t flags;
/* Disable interrupts until we are done. This guarantees that the following
* operations are atomic.
/* Disable interrupts until we are done. This guarantees that the
* following operations are atomic.
*/
flags = enter_critical_section();

8
boards/arm/sam34/sam4e-ek/src/sam_buttons.c
View File

@ -67,13 +67,13 @@
****************************************************************************/
#if defined(CONFIG_SAM34_GPIOA_IRQ) && defined(CONFIG_ARCH_IRQBUTTONS)
static int board_button_irqx(gpio_pinset_t pinset, int irq, xcpt_t irqhandler,
void *arg)
static int board_button_irqx(gpio_pinset_t pinset, int irq,
xcpt_t irqhandler, void *arg)
{
irqstate_t flags;
/* Disable interrupts until we are done. This guarantees that the following
* operations are atomic.
/* Disable interrupts until we are done. This guarantees that the
* following operations are atomic.
*/
flags = enter_critical_section();

1
boards/arm/sama5/sama5d3x-ek/src/sam_buttons.c
View File

@ -32,6 +32,7 @@
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/* There are five push button switches on the SAMA5D3X-EK base board:
*
* 1. One Reset, board reset (BP1)

1
boards/arm/sama5/sama5d4-ek/src/sam_buttons.c
View File

@ -32,6 +32,7 @@
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/* A single button, PB_USER1 (PB2), is available on the SAMA5D4-EK:
*
* ------------------------------ ------------------- ----------------------

4
boards/arm/samd2l2/samd20-xplained/src/sam_buttons.c
View File

@ -63,8 +63,8 @@
*
* Description:
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state of
* all buttons or board_button_irq() may be called to register button
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/

4
boards/arm/samd2l2/samd21-xplained/src/sam_buttons.c
View File

@ -63,8 +63,8 @@
*
* Description:
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state of
* all buttons or board_button_irq() may be called to register button
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/

4
boards/arm/samv7/same70-xplained/src/sam_buttons.c
View File

@ -85,8 +85,8 @@ static int board_button_irqx(gpio_pinset_t pinset, int irq,
{
irqstate_t flags;
/* Disable interrupts until we are done. This guarantees that the following
* operations are atomic.
/* Disable interrupts until we are done. This guarantees that the
* following operations are atomic.
*/
flags = enter_critical_section();

8
boards/arm/samv7/samv71-xult/src/sam_buttons.c
View File

@ -84,13 +84,13 @@
****************************************************************************/
#ifdef HAVE_IRQBUTTONS
static int board_button_irqx(gpio_pinset_t pinset, int irq, xcpt_t irqhandler,
void *arg)
static int board_button_irqx(gpio_pinset_t pinset, int irq,
xcpt_t irqhandler, void *arg)
{
irqstate_t flags;
/* Disable interrupts until we are done. This guarantees that the following
* operations are atomic.
/* Disable interrupts until we are done. This guarantees that the
* following operations are atomic.
*/
flags = enter_critical_section();

32
boards/arm/stm32/clicker2-stm32/src/stm32_buttons.c
View File

@ -61,10 +61,10 @@
* Name: board_button_initialize
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/
@ -106,20 +106,20 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* definitions in board.h for the meaning of enumeration
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/

43
boards/arm/stm32/cloudctrl/src/stm32_buttons.c
View File

@ -58,6 +58,7 @@
/****************************************************************************
* Private Data
****************************************************************************/
/* Pin configuration for each cloudctrl button. This array is indexed by
* the BUTTON_* definitions in board.h
*/
@ -80,9 +81,9 @@ static const uint32_t g_buttons[NUM_BUTTONS] =
*
* Description:
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state of
* all buttons or board_button_irq() may be called to register button interrupt
* handlers.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/
@ -115,22 +116,22 @@ uint32_t board_buttons(void)
for (i = 0; i < NUM_BUTTONS; i++)
{
/* A LOW value means that the key is pressed for most keys. The exception
* is the WAKEUP button.
*/
/* A LOW value means that the key is pressed for most keys.
* The exception is the WAKEUP button.
*/
bool released = stm32_gpioread(g_buttons[i]);
if (i == BUTTON_WAKEUP)
{
released = !released;
}
bool released = stm32_gpioread(g_buttons[i]);
if (i == BUTTON_WAKEUP)
{
released = !released;
}
/* Accumulate the set of depressed (not released) keys */
/* Accumulate the set of depressed (not released) keys */
if (!released)
{
ret |= (1 << i);
}
if (!released)
{
ret |= (1 << i);
}
}
return ret;
@ -141,9 +142,9 @@ uint32_t board_buttons(void)
*
* Description:
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state of
* all buttons or board_button_irq() may be called to register button interrupt
* handlers.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
@ -151,8 +152,8 @@ uint32_t board_buttons(void)
* BUTTON_*_BIT and JOYSTICK_*_BIT definitions in board.h for the meaning
* of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* and JOYSTICK_* definitions in board.h for the meaning of
* enumeration value.

20
boards/arm/stm32/fire-stm32v2/src/stm32_buttons.c
View File

@ -71,9 +71,9 @@
*
* Description:
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state of
* all buttons or board_button_irq() may be called to register button interrupt
* handlers.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/
@ -96,7 +96,9 @@ uint32_t board_buttons(void)
{
uint32_t ret = 0;
/* Check that state of each key. A LOW value means that the key is pressed, */
/* Check that state of each key.
* A LOW value means that the key is pressed.
*/
if (!stm32_gpioread(GPIO_BTN_KEY1))
{
@ -116,9 +118,9 @@ uint32_t board_buttons(void)
*
* Description:
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
@ -126,8 +128,8 @@ uint32_t board_buttons(void)
* BUTTON_*_BIT and JOYSTICK_*_BIT definitions in board.h for the meaning
* of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* and JOYSTICK_* definitions in board.h for the meaning of
* enumeration values.

29
boards/arm/stm32/hymini-stm32v/src/stm32_buttons.c
View File

@ -1,7 +1,8 @@
/****************************************************************************
* boards/arm/stm32/hymini-stm32v/src/stm32_buttons.c
*
* Copyright (C) 2009, 2011, 2014-2015, 2017 Gregory Nutt. All rights reserved.
* Copyright (C) 2009, 2011, 2014-2015, 2017 Gregory Nutt.
* All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Redistribution and use in source and binary forms, with or without
@ -61,9 +62,9 @@
*
* Description:
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state of
* all buttons or board_button_irq() may be called to register button interrupt
* handlers.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/
@ -81,14 +82,14 @@ uint32_t board_button_initialize(void)
uint32_t board_buttons(void)
{
uint32_t ret = 0;
bool pinValue;
bool value;
/* Check that state of each key */
/* Pin is pulled up */
pinValue = stm32_gpioread(GPIO_BTN_KEYA);
if (!pinValue)
value = stm32_gpioread(GPIO_BTN_KEYA);
if (!value)
{
/* Button pressed */
@ -97,8 +98,8 @@ uint32_t board_buttons(void)
/* Pin is pulled down */
pinValue = stm32_gpioread(GPIO_BTN_KEYB);
if (pinValue)
value = stm32_gpioread(GPIO_BTN_KEYB);
if (value)
{
/* Button pressed */
@ -113,9 +114,9 @@ uint32_t board_buttons(void)
*
* Description:
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state of
* all buttons or board_button_irq() may be called to register button interrupt
* handlers.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
@ -123,8 +124,8 @@ uint32_t board_buttons(void)
* BUTTON_*_BIT and JOYSTICK_*_BIT definitions in board.h for the meaning
* of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* definitions in board.h for the meaning of enumeration
* value.

3
boards/arm/stm32/nucleo-f207zg/src/stm32_buttons.c
View File

@ -98,7 +98,8 @@ uint32_t board_buttons(void)
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is
* a button enumeration value that uniquely identifies a button resource.
* See the BUTTON_* definitions in board.h for the meaning of enumeration value.
* See the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/

3
boards/arm/stm32/nucleo-f303ze/src/stm32_buttons.c
View File

@ -98,7 +98,8 @@ uint32_t board_buttons(void)
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is
* a button enumeration value that uniquely identifies a button resource.
* See the BUTTON_* definitions in board.h for the meaning of enumeration value.
* See the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/

27
boards/arm/stm32/nucleo-f410rb/src/stm32_buttons.c
View File

@ -93,20 +93,20 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* definitions in board.h for the meaning of enumeration
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/
@ -118,7 +118,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id == BUTTON_USER)
{
ret = stm32_gpiosetevent(GPIO_BTN_USER, true, true, true, irqhandler, arg);
ret = stm32_gpiosetevent(GPIO_BTN_USER, true, true, true,
irqhandler, arg);
}
return ret;

4
boards/arm/stm32/nucleo-f446re/src/stm32_buttons.c
View File

@ -94,8 +94,8 @@ uint32_t board_buttons(void)
*
* Description:
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state of
* all buttons or board_button_irq() may be called to register button
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be

27
boards/arm/stm32/nucleo-f4x1re/src/stm32_buttons.c
View File

@ -95,20 +95,20 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* definitions in board.h for the meaning of enumeration
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/
@ -120,7 +120,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id == BUTTON_USER)
{
ret = stm32_gpiosetevent(GPIO_BTN_USER, true, true, true, irqhandler, arg);
ret = stm32_gpiosetevent(GPIO_BTN_USER, true, true, true,
irqhandler, arg);
}
return ret;

4
boards/arm/stm32/olimex-stm32-e407/src/stm32_buttons.c
View File

@ -123,8 +123,8 @@ uint32_t board_buttons(void)
*
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is

39
boards/arm/stm32/olimex-stm32-h405/src/stm32_buttons.c
View File

@ -54,8 +54,8 @@
* Private Data
****************************************************************************/
/* Pin configuration for each Olimex-STM32-H405 button. This array is indexed by
* the BUTTON_* definitions in board.h
/* Pin configuration for each Olimex-STM32-H405 button. This array is indexed
* by the BUTTON_* definitions in board.h
*/
static const uint32_t g_buttons[NUM_BUTTONS] =
@ -71,10 +71,10 @@ static const uint32_t g_buttons[NUM_BUTTONS] =
* Name: board_button_initialize
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/
@ -116,20 +116,20 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* definitions in board.h for the meaning of enumeration
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/
@ -143,7 +143,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id >= MIN_IRQBUTTON && id <= MAX_IRQBUTTON)
{
ret = stm32_gpiosetevent(g_buttons[id], true, true, true, irqhandler, arg);
ret = stm32_gpiosetevent(g_buttons[id], true, true, true,
irqhandler, arg);
}
return ret;

8
boards/arm/stm32/olimex-stm32-h407/src/stm32_buttons.c
View File

@ -54,8 +54,8 @@
* Private Data
****************************************************************************/
/* Pin configuration for each Olimex-STM32-H405 button. This array is indexed by
* the BUTTON_* definitions in board.h
/* Pin configuration for each Olimex-STM32-H405 button. This array is indexed
* by the BUTTON_* definitions in board.h
*/
static const uint32_t g_buttons[NUM_BUTTONS] =
@ -123,8 +123,8 @@ uint32_t board_buttons(void)
*
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is

39
boards/arm/stm32/olimex-stm32-p207/src/stm32_buttons.c
View File

@ -54,8 +54,8 @@
* Private Data
****************************************************************************/
/* Pin configuration for each STM32F4 Discovery button. This array is indexed by
* the BUTTON_* definitions in board.h
/* Pin configuration for each STM32F4 Discovery button. This array is indexed
* by the BUTTON_* definitions in board.h
*/
static const uint32_t g_buttons[NUM_BUTTONS] =
@ -77,10 +77,10 @@ static const uint32_t g_buttons[NUM_BUTTONS] =
* Name: board_button_initialize
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/
@ -152,20 +152,20 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* definitions in board.h for the meaning of enumeration
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/
@ -179,7 +179,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id >= MIN_IRQBUTTON && id <= MAX_IRQBUTTON)
{
ret = stm32_gpiosetevent(g_buttons[id], true, true, true, irqhandler, arg);
ret = stm32_gpiosetevent(g_buttons[id], true, true, true,
irqhandler, arg);
}
return ret;

39
boards/arm/stm32/olimex-stm32-p407/src/stm32_buttons.c
View File

@ -56,8 +56,8 @@
* Private Data
****************************************************************************/
/* Pin configuration for each STM32F4 Discovery button. This array is indexed by
* the BUTTON_* definitions in board.h
/* Pin configuration for each STM32F4 Discovery button. This array is indexed
* by the BUTTON_* definitions in board.h
*/
static const uint32_t g_buttons[NUM_BUTTONS] =
@ -79,10 +79,10 @@ static const uint32_t g_buttons[NUM_BUTTONS] =
* Name: board_button_initialize
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/
@ -154,20 +154,20 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* definitions in board.h for the meaning of enumeration
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/
@ -181,7 +181,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id >= MIN_IRQBUTTON && id <= MAX_IRQBUTTON)
{
ret = stm32_gpiosetevent(g_buttons[id], true, true, true, irqhandler, arg);
ret = stm32_gpiosetevent(g_buttons[id], true, true, true,
irqhandler, arg);
}
return ret;

54
boards/arm/stm32/olimexino-stm32/src/olimexino-stm32.h
View File

@ -56,14 +56,14 @@
# undef CONFIG_STM32_SPI2
#endif
/* LEDs *****************************************************************************
/* LEDs *********************************************************************
*
* GPIO Function MPU Board
* Pin # Name
* -- ----- -------------------------------- ----------------------------
* GPIO Function MPU Board
* Pin # Name
* -- ----- -------------------------------- ----------------------------
*
* PA[05] PA5/SPI1_SCK/ADC5 21 D13(SCK1/LED1)
* PA[01] PA1/USART2_RTS/ADC1/TIM2_CH2 15 D3(LED2)
* PA[05] PA5/SPI1_SCK/ADC5 21 D13(SCK1/LED1)
* PA[01] PA1/USART2_RTS/ADC1/TIM2_CH2 15 D3(LED2)
*/
#define GPIO_LED1 (GPIO_OUTPUT | GPIO_CNF_OUTPP | GPIO_MODE_50MHz | \
@ -73,28 +73,28 @@
GPIO_PORTA | GPIO_PIN1 | GPIO_OUTPUT_CLEAR)
#define GPIO_LED_YELLOW GPIO_LED2
/* BUTTON ***************************************************************************
/* BUTTON *******************************************************************
*
* GPIO Function MPU Board
* Pin # Name
* -- ----- -------------------------------- ----------------------------
* GPIO Function MPU Board
* Pin # Name
* -- ----- -------------------------------- ----------------------------
*
* PC[09] PC9/TIM3_CH4 40 BOOT0
* PC[09] PC9/TIM3_CH4 40 BOOT0
*
*/
#define BUTTON_BOOT0n (GPIO_INPUT | GPIO_CNF_INFLOAT | GPIO_PORTC | GPIO_PIN9 | \
#define BUTTON_BOOT0N (GPIO_INPUT | GPIO_CNF_INFLOAT | GPIO_PORTC | GPIO_PIN9 | \
GPIO_EXTI)
#define IRQBUTTON BUTTON_BOOT0_BIT
/* USBs *****************************************************************************
/* USBs *********************************************************************
*
* GPIO Function MPU Board
* Pin # Name
* -- ----- -------------------------------- ----------------------------
* GPIO Function MPU Board
* Pin # Name
* -- ----- -------------------------------- ----------------------------
*
* PC[11] PC11/USART3_RX 52 USB_P
* PC[12] PC12/USART3_CK 53 DISC
* PC[11] PC11/USART3_RX 52 USB_P
* PC[12] PC12/USART3_CK 53 DISC
*
*/
@ -102,14 +102,14 @@
#define GPIO_USB_PULLUPn (GPIO_OUTPUT | GPIO_CNF_OUTPP | GPIO_MODE_50MHz | \
GPIO_PORTC | GPIO_PIN12 | GPIO_OUTPUT_SET)
/* SPI ***************************************************************************
/* SPI **********************************************************************
*
* GPIO Function MPU Board
* Pin # Name
* -- ----- -------------------------------- ----------------------------
* GPIO Function MPU Board
* Pin # Name
* -- ----- -------------------------------- ----------------------------
*
* PC[09] PA4/SPI1_NSS/USART2_CK/ADC4 20 D10(#SS1)
* PD[02] PD2/TIM3_ETR 54 D25(MMC_CS)
* PC[09] PA4/SPI1_NSS/USART2_CK/ADC4 20 D10(#SS1)
* PD[02] PD2/TIM3_ETR 54 D25(MMC_CS)
*/
#define GPIO_SPI1_SSn (GPIO_OUTPUT | GPIO_CNF_OUTPP | GPIO_MODE_50MHz | \
@ -131,7 +131,7 @@
#ifndef __ASSEMBLY__
/****************************************************************************
* Public Functions
* Public Functions Prototype
****************************************************************************/
/****************************************************************************
@ -164,8 +164,8 @@ void stm32_usbinitialize(void);
* Called to setup set a call back for USB power state changes.
*
* Input Parameters:
* pwr_changed_handler: An interrupt handler that will be called on VBUS power
* state changes.
* pwr_changed_handler: An interrupt handler that will be called on VBUS
* power state changes.
*
****************************************************************************/

12
boards/arm/stm32/olimexino-stm32/src/stm32_buttons.c
View File

@ -79,15 +79,15 @@
*
* Description:
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state of
* all buttons or board_button_irq() may be called to register button
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/
uint32_t board_button_initialize(void)
{
stm32_configgpio(BUTTON_BOOT0n);
stm32_configgpio(BUTTON_BOOT0N);
return 1;
}
@ -105,7 +105,7 @@ uint32_t board_button_initialize(void)
uint32_t board_buttons(void)
{
return stm32_gpioread(BUTTON_BOOT0n) ? 0 : BUTTON_BOOT0_MASK;
return stm32_gpioread(BUTTON_BOOT0N) ? 0 : BUTTON_BOOT0_MASK;
}
/****************************************************************************
@ -130,8 +130,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id == IRQBUTTON)
{
ret = stm32_gpiosetevent(BUTTON_BOOT0n, true, true, true, irqhandler,
arg);
ret = stm32_gpiosetevent(BUTTON_BOOT0N, true, true, true,
irqhandler, arg);
}
return ret;

64
boards/arm/stm32/shenzhou/src/stm32_buttons.c
View File

@ -71,10 +71,10 @@ static const uint32_t g_buttons[NUM_BUTTONS] =
* Name: board_button_initialize
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/
@ -107,22 +107,22 @@ uint32_t board_buttons(void)
for (i = 0; i < NUM_BUTTONS; i++)
{
/* A LOW value means that the key is pressed for most keys. The exception
* is the WAKEUP button.
*/
/* A LOW value means that the key is pressed for most keys.
* The exception is the WAKEUP button.
*/
bool released = stm32_gpioread(g_buttons[i]);
if (i == BUTTON_WAKEUP)
{
released = !released;
}
bool released = stm32_gpioread(g_buttons[i]);
if (i == BUTTON_WAKEUP)
{
released = !released;
}
/* Accumulate the set of depressed (not released) keys */
/* Accumulate the set of depressed (not released) keys */
if (!released)
{
ret |= (1 << i);
}
if (!released)
{
ret |= (1 << i);
}
}
return ret;
@ -132,21 +132,22 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT and JOYSTICK_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT and JOYSTICK_*_BIT definitions in board.h for the meaning
* of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* and JOYSTICK_* definitions in board.h for the meaning of enumeration
* value.
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* and JOYSTICK_* definitions in board.h for the meaning of
* enumeration value.
*
****************************************************************************/
@ -159,7 +160,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id >= MIN_IRQBUTTON && id <= MAX_IRQBUTTON)
{
ret = stm32_gpiosetevent(g_buttons[id], true, true, true, irqhandler, arg);
ret = stm32_gpiosetevent(g_buttons[id], true, true, true,
irqhandler, arg);
}
return ret;

68
boards/arm/stm32/stm3210e-eval/src/stm32_buttons.c
View File

@ -1,7 +1,8 @@
/****************************************************************************
* boards/arm/stm32/stm3210e-eval/src/stm32_buttons.c
*
* Copyright (C) 2009, 2011, 2014-2015, 2017 Gregory Nutt. All rights reserved.
* Copyright (C) 2009, 2011, 2014-2015, 2017 Gregory Nutt.
* All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Redistribution and use in source and binary forms, with or without
@ -54,6 +55,7 @@
/****************************************************************************
* Private Data
****************************************************************************/
/* Pin configuration for each STM3210E-EVAL button. This array is indexed by
* the BUTTON_* and JOYSTICK_* definitions in board.h
*/
@ -84,10 +86,10 @@ static const uint32_t g_buttons[NUM_BUTTONS] =
* Name: board_button_initialize
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/
@ -120,22 +122,22 @@ uint32_t board_buttons(void)
for (i = 0; i < NUM_BUTTONS; i++)
{
/* A LOW value means that the key is pressed for most keys. The exception
* is the WAKEUP button.
*/
/* A LOW value means that the key is pressed for most keys.
* The exception is the WAKEUP button.
*/
bool released = stm32_gpioread(g_buttons[i]);
if (i == BUTTON_WAKEUP)
{
released = !released;
}
bool released = stm32_gpioread(g_buttons[i]);
if (i == BUTTON_WAKEUP)
{
released = !released;
}
/* Accumulate the set of depressed (not released) keys */
/* Accumulate the set of depressed (not released) keys */
if (!released)
{
ret |= (1 << i);
}
if (!released)
{
ret |= (1 << i);
}
}
return ret;
@ -145,21 +147,22 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT and JOYSTICK_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT and JOYSTICK_*_BIT definitions in board.h for the meaning
* of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* and JOYSTICK_* definitions in board.h for the meaning of enumeration
* value.
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* and JOYSTICK_* definitions in board.h for the meaning of
* enumeration value.
*
****************************************************************************/
@ -172,7 +175,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id >= MIN_IRQBUTTON && id <= MAX_IRQBUTTON)
{
ret = stm32_gpiosetevent(g_buttons[id], true, true, true, irqhandler, arg);
ret = stm32_gpiosetevent(g_buttons[id], true, true, true,
irqhandler, arg);
}
return ret;

61
boards/arm/stm32/stm3220g-eval/src/stm32_buttons.c
View File

@ -71,10 +71,10 @@ static const uint32_t g_buttons[NUM_BUTTONS] =
* Name: board_button_initialize
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/
@ -107,22 +107,22 @@ uint32_t board_buttons(void)
for (i = 0; i < NUM_BUTTONS; i++)
{
/* A LOW value means that the key is pressed for most keys. The exception
* is the WAKEUP button.
*/
/* A LOW value means that the key is pressed for most keys.
* The exception is the WAKEUP button.
*/
bool released = stm32_gpioread(g_buttons[i]);
if (i == BUTTON_WAKEUP)
{
released = !released;
}
bool released = stm32_gpioread(g_buttons[i]);
if (i == BUTTON_WAKEUP)
{
released = !released;
}
/* Accumulate the set of depressed (not released) keys */
/* Accumulate the set of depressed (not released) keys */
if (!released)
{
ret |= (1 << i);
}
if (!released)
{
ret |= (1 << i);
}
}
return ret;
@ -132,20 +132,20 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* definitions in board.h for the meaning of enumeration
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/
@ -159,7 +159,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id >= MIN_IRQBUTTON && id <= MAX_IRQBUTTON)
{
ret = stm32_gpiosetevent(g_buttons[id], true, true, true, irqhandler, arg);
ret = stm32_gpiosetevent(g_buttons[id], true, true, true,
irqhandler, arg);
}
return ret;

61
boards/arm/stm32/stm3240g-eval/src/stm32_buttons.c
View File

@ -79,10 +79,10 @@ static const uint32_t g_buttons[NUM_BUTTONS] =
* Name: board_button_initialize
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/
@ -115,22 +115,22 @@ uint32_t board_buttons(void)
for (i = 0; i < NUM_BUTTONS; i++)
{
/* A LOW value means that the key is pressed for most keys. The exception
* is the WAKEUP button.
*/
/* A LOW value means that the key is pressed for most keys.
* The exception is the WAKEUP button.
*/
bool released = stm32_gpioread(g_buttons[i]);
if (i == BUTTON_WAKEUP)
{
released = !released;
}
bool released = stm32_gpioread(g_buttons[i]);
if (i == BUTTON_WAKEUP)
{
released = !released;
}
/* Accumulate the set of depressed (not released) keys */
/* Accumulate the set of depressed (not released) keys */
if (!released)
{
ret |= (1 << i);
}
if (!released)
{
ret |= (1 << i);
}
}
return ret;
@ -140,20 +140,20 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* definitions in board.h for the meaning of enumeration
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/
@ -167,7 +167,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id >= MIN_IRQBUTTON && id <= MAX_IRQBUTTON)
{
ret = stm32_gpiosetevent(g_buttons[id], true, true, true, irqhandler, arg);
ret = stm32_gpiosetevent(g_buttons[id], true, true, true,
irqhandler, arg);
}
return ret;

16
boards/arm/stm32/stm32butterfly2/src/stm32_buttons.c
View File

@ -1,4 +1,4 @@
/*****************************************************************************
/****************************************************************************
* boards/arm/stm32/stm32butterfly2/src/stm32_buttons.c
*
* Copyright (C) 2016 Michał Łyszczek. All rights reserved.
@ -32,13 +32,13 @@
* POSSIBILITY OF SUCH DAMAGE.
****************************************************************************/
/*****************************************************************************
* Public Includes
/****************************************************************************
* Included Files
****************************************************************************/
#include "stm32_gpio.h"
/*****************************************************************************
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
@ -55,7 +55,7 @@
#define GPIO_JOY_L (GPIO_INPUT | GPIO_CNF_INFLOAT | GPIO_MODE_INPUT |\
GPIO_PORTC | GPIO_PIN11)
/*****************************************************************************
/****************************************************************************
* Private Declarations
****************************************************************************/
@ -64,11 +64,11 @@ static const uint32_t buttons[NUM_BUTTONS] =
GPIO_JOY_O, GPIO_JOY_U, GPIO_JOY_D, GPIO_JOY_R, GPIO_JOY_L
};
/*****************************************************************************
/****************************************************************************
* Public Functions
****************************************************************************/
/*****************************************************************************
/****************************************************************************
* Name: board_button_initialize
*
* Description:
@ -87,7 +87,7 @@ uint32_t board_button_initialize(void)
return NUM_BUTTONS;
}
/*****************************************************************************
/****************************************************************************
* Name: board_buttons
*
* Description:

15
boards/arm/stm32/stm32f103-minimum/src/stm32_buttons.c
View File

@ -116,17 +116,16 @@ uint32_t board_buttons(void)
for (i = 0; i < NUM_BUTTONS; i++)
{
/* A LOW value means that the key is pressed.
*/
/* A LOW value means that the key is pressed. */
bool released = stm32_gpioread(g_buttons[i]);
bool released = stm32_gpioread(g_buttons[i]);
/* Accumulate the set of depressed (not released) keys */
/* Accumulate the set of depressed (not released) keys */
if (!released)
{
ret |= (1 << i);
}
if (!released)
{
ret |= (1 << i);
}
}
return ret;

54
boards/arm/stm32/stm32f3discovery/src/stm32_buttons.c
View File

@ -54,8 +54,8 @@
* Private Data
****************************************************************************/
/* Pin configuration for each STM32F3Discovery button. This array is indexed by
* the BUTTON_* definitions in board.h
/* Pin configuration for each STM32F3Discovery button. This array is indexed
* by the BUTTON_* definitions in board.h
*/
static const uint32_t g_buttons[NUM_BUTTONS] =
@ -71,10 +71,10 @@ static const uint32_t g_buttons[NUM_BUTTONS] =
* Name: board_button_initialize
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/
@ -107,17 +107,16 @@ uint32_t board_buttons(void)
for (i = 0; i < NUM_BUTTONS; i++)
{
/* A LOW value means that the key is pressed.
*/
/* A LOW value means that the key is pressed. */
bool released = stm32_gpioread(g_buttons[i]);
bool released = stm32_gpioread(g_buttons[i]);
/* Accumulate the set of depressed (not released) keys */
/* Accumulate the set of depressed (not released) keys */
if (!released)
{
ret |= (1 << i);
}
if (!released)
{
ret |= (1 << i);
}
}
return ret;
@ -127,20 +126,20 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* definitions in board.h for the meaning of enumeration
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/
@ -154,7 +153,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id >= MIN_IRQBUTTON && id <= MAX_IRQBUTTON)
{
ret = stm32_gpiosetevent(g_buttons[id], true, true, true, irqhandler, arg);
ret = stm32_gpiosetevent(g_buttons[id], true, true, true,
irqhandler, arg);
}
return ret;

57
boards/arm/stm32/stm32f429i-disco/src/stm32_buttons.c
View File

@ -1,7 +1,8 @@
/****************************************************************************
* boards/arm/stm32/stm32f429i-disco/src/stm32_buttons.c
*
* Copyright (C) 2011-2012, 2014-2015, 2017 Gregory Nutt. All rights reserved.
* Copyright (C) 2011-2012, 2014-2015, 2017 Gregory Nutt.
* All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Redistribution and use in source and binary forms, with or without
@ -54,8 +55,8 @@
* Private Data
****************************************************************************/
/* Pin configuration for each STM32F4 Discovery button. This array is indexed by
* the BUTTON_* definitions in board.h
/* Pin configuration for each STM32F4 Discovery button. This array is indexed
* by the BUTTON_* definitions in board.h
*/
static const uint32_t g_buttons[NUM_BUTTONS] =
@ -71,10 +72,10 @@ static const uint32_t g_buttons[NUM_BUTTONS] =
* Name: board_button_initialize
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/
@ -107,17 +108,16 @@ uint32_t board_buttons(void)
for (i = 0; i < NUM_BUTTONS; i++)
{
/* A LOW value means that the key is pressed.
*/
/* A LOW value means that the key is pressed. */
bool released = stm32_gpioread(g_buttons[i]);
bool released = stm32_gpioread(g_buttons[i]);
/* Accumulate the set of depressed (not released) keys */
/* Accumulate the set of depressed (not released) keys */
if (!released)
{
ret |= (1 << i);
}
if (!released)
{
ret |= (1 << i);
}
}
return ret;
@ -127,20 +127,20 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* definitions in board.h for the meaning of enumeration
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/
@ -154,7 +154,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id >= MIN_IRQBUTTON && id <= MAX_IRQBUTTON)
{
ret = stm32_gpiosetevent(g_buttons[id], true, true, true, irqhandler, arg);
ret = stm32_gpiosetevent(g_buttons[id], true, true, true,
irqhandler, arg);
}
return ret;

57
boards/arm/stm32/stm32f4discovery/src/stm32_buttons.c
View File

@ -1,7 +1,8 @@
/****************************************************************************
* boards/arm/stm32/stm32f4discovery/src/stm32_buttons.c
*
* Copyright (C) 2011-2012, 2014-2015, 2017 Gregory Nutt. All rights reserved.
* Copyright (C) 2011-2012, 2014-2015, 2017 Gregory Nutt.
* All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Redistribution and use in source and binary forms, with or without
@ -55,8 +56,8 @@
* Private Data
****************************************************************************/
/* Pin configuration for each STM32F4 Discovery button. This array is indexed by
* the BUTTON_* definitions in board.h
/* Pin configuration for each STM32F4 Discovery button. This array is indexed
* by the BUTTON_* definitions in board.h
*/
static const uint32_t g_buttons[NUM_BUTTONS] =
@ -72,10 +73,10 @@ static const uint32_t g_buttons[NUM_BUTTONS] =
* Name: board_button_initialize
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/
@ -108,17 +109,16 @@ uint32_t board_buttons(void)
for (i = 0; i < NUM_BUTTONS; i++)
{
/* A LOW value means that the key is pressed.
*/
/* A LOW value means that the key is pressed. */
bool released = stm32_gpioread(g_buttons[i]);
bool released = stm32_gpioread(g_buttons[i]);
/* Accumulate the set of depressed (not released) keys */
/* Accumulate the set of depressed (not released) keys */
if (!released)
{
ret |= (1 << i);
}
if (!released)
{
ret |= (1 << i);
}
}
return ret;
@ -128,20 +128,20 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* definitions in board.h for the meaning of enumeration
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/
@ -155,7 +155,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id >= MIN_IRQBUTTON && id <= MAX_IRQBUTTON)
{
ret = stm32_gpiosetevent(g_buttons[id], true, true, true, irqhandler, arg);
ret = stm32_gpiosetevent(g_buttons[id], true, true, true,
irqhandler, arg);
}
return ret;

54
boards/arm/stm32/stm32ldiscovery/src/stm32_buttons.c
View File

@ -55,8 +55,8 @@
* Private Data
****************************************************************************/
/* Pin configuration for each STM32F3Discovery button. This array is indexed by
* the BUTTON_* definitions in board.h
/* Pin configuration for each STM32F3Discovery button. This array is indexed
* by the BUTTON_* definitions in board.h
*/
static const uint32_t g_buttons[NUM_BUTTONS] =
@ -72,10 +72,10 @@ static const uint32_t g_buttons[NUM_BUTTONS] =
* Name: board_button_initialize
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/
@ -108,17 +108,16 @@ uint32_t board_buttons(void)
for (i = 0; i < NUM_BUTTONS; i++)
{
/* A LOW value means that the key is pressed.
*/
/* A LOW value means that the key is pressed. */
bool released = stm32_gpioread(g_buttons[i]);
bool released = stm32_gpioread(g_buttons[i]);
/* Accumulate the set of depressed (not released) keys */
/* Accumulate the set of depressed (not released) keys */
if (!released)
{
ret |= (1 << i);
}
if (!released)
{
ret |= (1 << i);
}
}
return ret;
@ -128,20 +127,20 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* definitions in board.h for the meaning of enumeration
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/
@ -155,7 +154,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id >= MIN_IRQBUTTON && id <= MAX_IRQBUTTON)
{
ret = stm32_gpiosetevent(g_buttons[id], true, true, true, irqhandler, arg);
ret = stm32_gpiosetevent(g_buttons[id], true, true, true,
irqhandler, arg);
}
return ret;

38
boards/arm/stm32/stm32vldiscovery/src/stm32_buttons.c
View File

@ -59,10 +59,10 @@
* Name: board_button_initialize
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/
@ -89,21 +89,22 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT and JOYSTICK_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT and JOYSTICK_*_BIT definitions in board.h for the meaning
* of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* and JOYSTICK_* definitions in board.h for the meaning of enumeration
* value.
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* and JOYSTICK_* definitions in board.h for the meaning of
* enumeration value.
*
****************************************************************************/
@ -114,7 +115,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id == 0)
{
ret = stm32_gpiosetevent(GPIO_BTN_0, true, true, true, irqhandler, arg);
ret = stm32_gpiosetevent(GPIO_BTN_0, true, true, true,
irqhandler, arg);
}
return ret;

42
boards/arm/stm32/viewtool-stm32f107/src/stm32_buttons.c
View File

@ -71,10 +71,10 @@ static const uint32_t g_buttons[NUM_BUTTONS] =
* Name: board_button_initialize
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/
@ -107,8 +107,8 @@ uint32_t board_buttons(void)
for (i = 0; i < NUM_BUTTONS; i++)
{
/* A LOW value means that the key is pressed for most keys. The exception
* is the WAKEUP button.
/* A LOW value means that the key is pressed for most keys. The
* exception is the WAKEUP button.
*/
bool released = stm32_gpioread(g_buttons[i]);
@ -128,21 +128,22 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT and JOYSTICK_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT and JOYSTICK_*_BIT definitions in board.h for the meaning
* of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* and JOYSTICK_* definitions in board.h for the meaning of enumeration
* value.
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* and JOYSTICK_* definitions in board.h for the meaning of
* enumeration value.
*
****************************************************************************/
@ -155,7 +156,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id >= MIN_IRQBUTTON && id <= MAX_IRQBUTTON)
{
ret = stm32_gpiosetevent(g_buttons[id], true, true, true, irqhandler, arg);
ret = stm32_gpiosetevent(g_buttons[id], true, true, true,
irqhandler, arg);
}
return ret;

27
boards/arm/stm32f0l0g0/nucleo-f072rb/src/stm32_buttons.c
View File

@ -95,20 +95,20 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* definitions in board.h for the meaning of enumeration
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/
@ -120,7 +120,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id == BUTTON_USER)
{
ret = stm32_gpiosetevent(GPIO_BTN_USER, true, true, true, irqhandler, arg);
ret = stm32_gpiosetevent(GPIO_BTN_USER, true, true, true,
irqhandler, arg);
}
return ret;

27
boards/arm/stm32f0l0g0/nucleo-f091rc/src/stm32_buttons.c
View File

@ -95,20 +95,20 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* definitions in board.h for the meaning of enumeration
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/
@ -120,7 +120,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id == BUTTON_USER)
{
ret = stm32_gpiosetevent(GPIO_BTN_USER, true, true, true, irqhandler, arg);
ret = stm32_gpiosetevent(GPIO_BTN_USER, true, true, true,
irqhandler, arg);
}
return ret;

9
boards/arm/stm32f0l0g0/nucleo-g070rb/src/stm32_buttons.c
View File

@ -100,8 +100,8 @@ uint32_t board_buttons(void)
*
* Description:
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state of
* all buttons or board_button_irq() may be called to register button
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be
@ -110,9 +110,10 @@ uint32_t board_buttons(void)
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* definitions in board.h for the meaning of enumeration value.
* the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/

27
boards/arm/stm32f0l0g0/nucleo-g071rb/src/stm32_buttons.c
View File

@ -96,20 +96,20 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* definitions in board.h for the meaning of enumeration
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/
@ -121,7 +121,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id == BUTTON_USER)
{
ret = stm32_gpiosetevent(GPIO_BTN_USER, true, true, true, irqhandler, arg);
ret = stm32_gpiosetevent(GPIO_BTN_USER, true, true, true,
irqhandler, arg);
}
return ret;

27
boards/arm/stm32f0l0g0/nucleo-l073rz/src/stm32_buttons.c
View File

@ -96,20 +96,20 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* definitions in board.h for the meaning of enumeration
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/
@ -121,7 +121,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id == BUTTON_USER)
{
ret = stm32_gpiosetevent(GPIO_BTN_USER, true, true, true, irqhandler, arg);
ret = stm32_gpiosetevent(GPIO_BTN_USER, true, true, true,
irqhandler, arg);
}
return ret;

54
boards/arm/stm32f0l0g0/stm32f051-discovery/src/stm32_buttons.c
View File

@ -55,8 +55,8 @@
* Private Data
****************************************************************************/
/* Pin configuration for each STM32F3Discovery button. This array is indexed by
* the BUTTON_* definitions in board.h
/* Pin configuration for each STM32F3Discovery button. This array is indexed
* by the BUTTON_* definitions in board.h
*/
static const uint32_t g_buttons[NUM_BUTTONS] =
@ -72,10 +72,10 @@ static const uint32_t g_buttons[NUM_BUTTONS] =
* Name: board_button_initialize
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/
@ -108,17 +108,16 @@ uint8_t board_buttons(void)
for (i = 0; i < NUM_BUTTONS; i++)
{
/* A LOW value means that the key is pressed.
*/
/* A LOW value means that the key is pressed. */
bool released = stm32_gpioread(g_buttons[i]);
bool released = stm32_gpioread(g_buttons[i]);
/* Accumulate the set of depressed (not released) keys */
/* Accumulate the set of depressed (not released) keys */
if (!released)
{
ret |= (1 << i);
}
if (!released)
{
ret |= (1 << i);
}
}
return ret;
@ -128,20 +127,20 @@ uint8_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 8-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 8-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* definitions in board.h for the meaning of enumeration
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/
@ -155,7 +154,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id >= MIN_IRQBUTTON && id <= MAX_IRQBUTTON)
{
ret = stm32_gpiosetevent(g_buttons[id], true, true, true, irqhandler, arg);
ret = stm32_gpiosetevent(g_buttons[id], true, true, true,
irqhandler, arg);
}
return ret;

54
boards/arm/stm32f0l0g0/stm32f072-discovery/src/stm32_buttons.c
View File

@ -55,8 +55,8 @@
* Private Data
****************************************************************************/
/* Pin configuration for each STM32F3Discovery button. This array is indexed by
* the BUTTON_* definitions in board.h
/* Pin configuration for each STM32F3Discovery button. This array is
* indexed by the BUTTON_* definitions in board.h
*/
static const uint32_t g_buttons[NUM_BUTTONS] =
@ -72,10 +72,10 @@ static const uint32_t g_buttons[NUM_BUTTONS] =
* Name: board_button_initialize
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/
@ -108,17 +108,16 @@ uint8_t board_buttons(void)
for (i = 0; i < NUM_BUTTONS; i++)
{
/* A LOW value means that the key is pressed.
*/
/* A LOW value means that the key is pressed. */
bool released = stm32_gpioread(g_buttons[i]);
bool released = stm32_gpioread(g_buttons[i]);
/* Accumulate the set of depressed (not released) keys */
/* Accumulate the set of depressed (not released) keys */
if (!released)
{
ret |= (1 << i);
}
if (!released)
{
ret |= (1 << i);
}
}
return ret;
@ -128,20 +127,20 @@ uint8_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 8-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 8-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* definitions in board.h for the meaning of enumeration
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/
@ -155,7 +154,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id >= MIN_IRQBUTTON && id <= MAX_IRQBUTTON)
{
ret = stm32_gpiosetevent(g_buttons[id], true, true, true, irqhandler, arg);
ret = stm32_gpiosetevent(g_buttons[id], true, true, true,
irqhandler, arg);
}
return ret;

27
boards/arm/stm32f7/nucleo-144/src/stm32_buttons.c
View File

@ -87,20 +87,20 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* definitions in board.h for the meaning of enumeration
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/
@ -112,7 +112,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id == BUTTON_USER)
{
ret = stm32_gpiosetevent(GPIO_BTN_USER, true, true, true, irqhandler, arg);
ret = stm32_gpiosetevent(GPIO_BTN_USER, true, true, true,
irqhandler, arg);
}
return ret;

27
boards/arm/stm32f7/stm32f746g-disco/src/stm32_buttons.c
View File

@ -85,20 +85,20 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* definitions in board.h for the meaning of enumeration
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/
@ -110,7 +110,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id == BUTTON_USER)
{
ret = stm32_gpiosetevent(GPIO_BTN_USER, true, true, true, irqhandler, arg);
ret = stm32_gpiosetevent(GPIO_BTN_USER, true, true, true,
irqhandler, arg);
}
return ret;

24
boards/arm/stm32f7/stm32f769i-disco/src/stm32_buttons.c
View File

@ -83,20 +83,20 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* definitions in board.h for the meaning of enumeration
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/

3
boards/arm/stm32h7/nucleo-h743zi/src/stm32_buttons.c
View File

@ -98,7 +98,8 @@ uint32_t board_buttons(void)
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is
* a button enumeration value that uniquely identifies a button resource.
* See the BUTTON_* definitions in board.h for the meaning of enumeration value.
* See the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/

16
boards/arm/stm32l4/nucleo-l432kc/src/stm32_buttons.c
View File

@ -89,13 +89,13 @@ uint32_t board_buttons(void)
return !released;
}
/******************************************************************************
/****************************************************************************
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state of
* all buttons or board_button_irq() may be called to register button
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be
@ -103,13 +103,13 @@ uint32_t board_buttons(void)
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
******************************************************************************/
****************************************************************************/
#ifdef CONFIG_ARCH_IRQBUTTONS
int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
@ -118,8 +118,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id == BUTTON_USER)
{
ret = stm32_gpiosetevent(GPIO_BTN_USER, true, true, true, irqhandler,
arg);
ret = stm32_gpiosetevent(GPIO_BTN_USER, true, true, true,
irqhandler, arg);
}
return ret;

27
boards/arm/stm32l4/nucleo-l452re/src/stm32_buttons.c
View File

@ -96,20 +96,20 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* definitions in board.h for the meaning of enumeration
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource.
* See the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/
@ -121,7 +121,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id == BUTTON_USER)
{
ret = stm32l4_gpiosetevent(GPIO_BTN_USER, true, true, true, irqhandler, arg);
ret = stm32l4_gpiosetevent(GPIO_BTN_USER, true, true, true,
irqhandler, arg);
}
return ret;

27
boards/arm/stm32l4/nucleo-l476rg/src/stm32_buttons.c
View File

@ -93,20 +93,20 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* definitions in board.h for the meaning of enumeration
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/
@ -118,7 +118,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id == BUTTON_USER)
{
ret = stm32l4_gpiosetevent(GPIO_BTN_USER, true, true, true, irqhandler, arg);
ret = stm32l4_gpiosetevent(GPIO_BTN_USER, true, true, true,
irqhandler, arg);
}
return ret;

27
boards/arm/stm32l4/nucleo-l496zg/src/stm32_buttons.c
View File

@ -87,20 +87,20 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* definitions in board.h for the meaning of enumeration
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See
* the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/
@ -112,7 +112,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id == BUTTON_USER)
{
ret = stm32l4_gpiosetevent(GPIO_BTN_USER, true, true, true, irqhandler, arg);
ret = stm32l4_gpiosetevent(GPIO_BTN_USER, true, true, true,
irqhandler, arg);
}
return ret;

20
boards/arm/stm32l4/stm32l476-mdk/src/stm32_buttons.c
View File

@ -108,22 +108,22 @@ uint32_t board_buttons(void)
for (i = 0; i < NUM_BUTTONS; i++)
{
/* A LOW value means that the key is pressed. */
/* A LOW value means that the key is pressed. */
bool released = stm32l4_gpioread(g_buttons[i]);
bool released = stm32l4_gpioread(g_buttons[i]);
/* Accumulate the set of depressed (not released) keys */
/* Accumulate the set of depressed (not released) keys */
if (!released)
{
ret |= (1 << i);
}
if (!released)
{
ret |= (1 << i);
}
}
return ret;
}
/*****************************************************************************
/****************************************************************************
* Button support.
*
* Description:
@ -138,8 +138,8 @@ uint32_t board_buttons(void)
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value
* is a button enumeration value that uniquely identifies a button resource.
* will be called when a button is depressed or released. The ID value is
* a button enumeration value that uniquely identifies a button resource.
* See the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*

49
boards/arm/stm32l4/stm32l476vg-disco/src/stm32_buttons.c
View File

@ -120,36 +120,39 @@ static void button_pm_notify(struct pm_callback_s *cb, int domain,
{
case(PM_NORMAL):
{
/* Restore normal buttons operation */
//XXX turn on any GPIO
/* Restore normal buttons operation
* XXX turn on any GPIO
*/
}
break;
case(PM_IDLE):
{
/* Entering IDLE mode - buttons */
//XXX turn on any GPIO
/* Entering IDLE mode - buttons
* XXX turn on any GPIO
*/
}
break;
case(PM_STANDBY):
{
/* Entering STANDBY mode - Logic for PM_STANDBY goes here */
//XXX turn off any GPIO
/* Entering STANDBY mode - Logic for PM_STANDBY goes here
* XXX turn off any GPIO
*/
}
break;
case(PM_SLEEP):
{
/* Entering SLEEP mode - Logic for PM_SLEEP goes here */
//XXX turn off any GPIO
/* Entering SLEEP mode - Logic for PM_SLEEP goes here
* XXX turn off any GPIO
*/
}
break;
default:
{
/* Should not get here */
}
break;
}
@ -163,6 +166,7 @@ static void button_pm_notify(struct pm_callback_s *cb, int domain,
* Handle a button wake-up interrupt
*
****************************************************************************/
/* XXX it's not completely clear to me if this is appropriate; on the one
* hand, it seems to make sense that this would be the module to have the ISR
* for the buttons. On the other hand, it will conflict with things done in
@ -299,20 +303,20 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* definitions in board.h for the meaning of enumeration
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is
* a button enumeration value that uniquely identifies a button resource.
* See the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/
@ -326,7 +330,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id >= MIN_IRQBUTTON && id <= MAX_IRQBUTTON)
{
ret = stm32l4_gpiosetevent(g_buttons[id], true, true, true, irqhandler, arg);
ret = stm32l4_gpiosetevent(g_buttons[id], true, true, true,
irqhandler, arg);
}
return ret;

49
boards/arm/stm32l4/stm32l4r9ai-disco/src/stm32_buttons.c
View File

@ -119,36 +119,39 @@ static void button_pm_notify(struct pm_callback_s *cb, int domain,
{
case(PM_NORMAL):
{
/* Restore normal buttons operation */
//XXX turn on any GPIO
/* Restore normal buttons operation
* XXX turn on any GPIO
*/
}
break;
case(PM_IDLE):
{
/* Entering IDLE mode - buttons */
//XXX turn on any GPIO
/* Entering IDLE mode - buttons
* XXX turn on any GPIO
*/
}
break;
case(PM_STANDBY):
{
/* Entering STANDBY mode - Logic for PM_STANDBY goes here */
//XXX turn off any GPIO
/* Entering STANDBY mode - Logic for PM_STANDBY goes here
* XXX turn off any GPIO
*/
}
break;
case(PM_SLEEP):
{
/* Entering SLEEP mode - Logic for PM_SLEEP goes here */
//XXX turn off any GPIO
/* Entering SLEEP mode - Logic for PM_SLEEP goes here
* XXX turn off any GPIO
*/
}
break;
default:
{
/* Should not get here */
}
break;
}
@ -162,6 +165,7 @@ static void button_pm_notify(struct pm_callback_s *cb, int domain,
* Handle a button wake-up interrupt
*
****************************************************************************/
/* XXX it's not completely clear to me if this is appropriate; on the one
* hand, it seems to make sense that this would be the module to have the ISR
* for the buttons. On the other hand, it will conflict with things done in
@ -298,20 +302,20 @@ uint32_t board_buttons(void)
* Button support.
*
* Description:
* board_button_initialize() must be called to initialize button resources. After
* that, board_buttons() may be called to collect the current state of all
* buttons or board_button_irq() may be called to register button interrupt
* handlers.
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* After board_button_initialize() has been called, board_buttons() may be called to
* collect the state of all buttons. board_buttons() returns an 32-bit bit set
* with each bit associated with a button. See the BUTTON_*_BIT
* definitions in board.h for the meaning of each bit.
* After board_button_initialize() has been called, board_buttons() may be
* called to collect the state of all buttons. board_buttons() returns an
* 32-bit bit set with each bit associated with a button. See the
* BUTTON_*_BIT definitions in board.h for the meaning of each bit.
*
* board_button_irq() may be called to register an interrupt handler that will
* be called when a button is depressed or released. The ID value is a
* button enumeration value that uniquely identifies a button resource. See the
* BUTTON_* definitions in board.h for the meaning of enumeration
* board_button_irq() may be called to register an interrupt handler that
* will be called when a button is depressed or released. The ID value is
* a button enumeration value that uniquely identifies a button resource.
* See the BUTTON_* definitions in board.h for the meaning of enumeration
* value.
*
****************************************************************************/
@ -325,7 +329,8 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
if (id >= MIN_IRQBUTTON && id <= MAX_IRQBUTTON)
{
ret = stm32l4_gpiosetevent(g_buttons[id], true, true, true, irqhandler, arg);
ret = stm32l4_gpiosetevent(g_buttons[id], true, true, true,
irqhandler, arg);
}
return ret;

4
boards/arm/tiva/dk-tm4c129x/src/tm4c_buttons.c
View File

@ -160,7 +160,9 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg)
irqstate_t flags;
int ret = -EINVAL;
/* Interrupts are supported only on ports P and Q and, hence, only on button SW4 */
/* Interrupts are supported only on ports P and Q and,
* hence, only on button SW4
*/
if (id == BUTTON_SW4)
{

4
boards/arm/tiva/tm4c123g-launchpad/src/tm4c_buttons.c
View File

@ -72,8 +72,8 @@
*
* Description:
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state of
* all buttons or board_button_irq() may be called to register button
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/

1
boards/arm/tiva/tm4c1294-launchpad/src/tm4c_buttons.c
View File

@ -58,6 +58,7 @@
/****************************************************************************
* Private Data
****************************************************************************/
/* Pin configuration for each STM3210E-EVAL button. This array is indexed by
* the BUTTON_* and JOYSTICK_* definitions in board.h
*/

4
boards/arm/tms570/launchxl-tms57004/src/tms570_buttons.c
View File

@ -90,8 +90,8 @@ static int board_button_irqx(gio_pinset_t pinset, int irq,
{
irqstate_t flags;
/* Disable interrupts until we are done. This guarantees that the following
* operations are atomic.
/* Disable interrupts until we are done. This guarantees that the
* following operations are atomic.
*/
flags = enter_critical_section();

4
boards/arm/tms570/tms570ls31x-usb-kit/src/tms570_buttons.c
View File

@ -90,8 +90,8 @@ static int board_button_irqx(gio_pinset_t pinset, int irq,
{
irqstate_t flags;
/* Disable interrupts until we are done. This guarantees that the following
* operations are atomic.
/* Disable interrupts until we are done. This guarantees that the
* following operations are atomic.
*/
flags = enter_critical_section();

21
boards/mips/pic32mx/sure-pic32mx/src/pic32mx_buttons.c
View File

@ -60,18 +60,19 @@
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
/* The Sure DB_DP11215 PIC32 Storage Demo Board has three buttons.
*
* SW1 (SW_UP, left arrow) RB3 Pulled high, Grounded/low when depressed
* SW2 (SW_DOWN, down/right arrow) RB2 Pulled high, Grounded/low when depressed
* SW3 (SW_OK, right arrow) RB4 Pulled high, Grounded/low when depressed
* SW1 (SW_UP, left arrow) RB3 Pulled high, Grounded/low when depressed
* SW2 (SW_DOWN, down arrow) RB2 Pulled high, Grounded/low when depressed
* SW3 (SW_OK, right arrow) RB4 Pulled high, Grounded/low when depressed
*
* The Sure DB-DP11212 PIC32 General Purpose Demo Board also has three buttons,
* but these are connected differently:
* The Sure DB-DP11212 PIC32 General Purpose Demo Board also has three
* buttons, but these are connected differently:
*
* SW2-1 RF0 Pulled high, Grounded/low when depressed
* SW3-1 RF1 Pulled high, Grounded/low when depressed
* SW5-1 RD6 Pulled high, Grounded/low when depressed
* SW2-1 RF0 Pulled high, Grounded/low when depressed
* SW3-1 RF1 Pulled high, Grounded/low when depressed
* SW5-1 RD6 Pulled high, Grounded/low when depressed
*
* Internal pull-ups are not required since the LEDs are pull-up externally.
* Change notification interrupts are not *automatically* enabled. Change
@ -131,8 +132,8 @@ static const uint8_t g_buttoncn[NUM_BUTTONS] =
*
* Description:
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state of
* all buttons or board_button_irq() may be called to register button
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/

4
boards/risc-v/fe310/hifive1-revb/src/fe310_buttons.c
View File

@ -66,8 +66,8 @@
*
* Description:
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state of
* all buttons or board_button_irq() may be called to register button
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
****************************************************************************/

25
include/nuttx/board.h
View File

@ -32,6 +32,7 @@
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/* This header file contains function prototypes for the interfaces between
* (1) the nuttx core-code, (2) the microprocessor specific logic that
* resides under the arch/ sub-directory, and (3) the board-specific logic
@ -50,8 +51,8 @@
* nuttx/include/arch.h
*
* NOTE: up_ is supposed to stand for microprocessor; the u is like the
* Greek letter micron: µ. So it would be µP which is a common shortening
* of the word microprocessor.
* Greek letter micron: µ. So it would be µP which is a common
* shortening of the word microprocessor.
*
* 2. Microprocessor-Specific Interfaces.
*
@ -610,12 +611,12 @@ void board_userled_all(uint8_t ledset);
*
* Description:
* board_button_initialize() must be called to initialize button resources.
* After that, board_buttons() may be called to collect the current state of
* all buttons or board_button_irq() may be called to register button interrupt
* handlers.
* After that, board_buttons() may be called to collect the current state
* of all buttons or board_button_irq() may be called to register button
* interrupt handlers.
*
* NOTE: This interface may or may not be supported by board-specific
* logic. If the board supports button interfaces, then CONFIG_ARCH_BUTTONS
* logic. If the board supports button interfaces, then CONFIG_ARCH_BUTTONS
* will be defined.
* NOTE: The button number is returned.
*
@ -670,14 +671,14 @@ int board_button_irq(int id, xcpt_t irqhandler, FAR void *arg);
*
* Description:
* If CONFIG_BOARD_CRASHDUMP is selected then up_asseert will call out to
* board_crashdump prior to calling exit in the case of an assertion failure.
* Or in the case of a hardfault looping indefinitely. board_crashdump then
* has a chance to save the state of the machine. The provided
* board_crashdump should save as much information as it can about the cause
* of the fault and then most likely reset the system.
* board_crashdump prior to calling exit in the case of an assertion
* failure. Or in the case of a hardfault looping indefinitely.
* board_crashdump then has a chance to save the state of the machine.
* The provided board_crashdump should save as much information as it can
* about the cause of the fault and then most likely reset the system.
*
* N.B. There are limited system resources that can be used by the provided
* board_crashdump function. The tems from the fact that most critical/fatal
* board_crashdump. The tems from the fact that most critical/fatal
* crashes are because of a hard fault or during interrupt processing.
* In these cases, up_assert is running from the context of an interrupt
* handlerand it is impossible to use any device driver in this context.