p_chinagoldgroup_hand_acid_libs
/
chinagoldgroup_hand_acid_stm32_sdk
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
9 Commits
1 Branch
0 Tags
548 KiB
 
 
Tree: 7c43d46dec
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '7c43d46dec'
${ noResults }
chinagoldgroup_hand_acid_st.../zgpio.cpp

489 lines
12 KiB
Raw Blame History

#include "zgpio.hpp"
extern "C" {
#include "logger.h"
}
#define TAG "GPIO"
#define PC_IRQ_PREEMPTPRIORITY_DEFAULT 5
namespace iflytop {
/*******************************************************************************
* LISTENER *
*******************************************************************************/
static ZGPIO *s_irqGPIO[20];
int s_irqGPIO_num = 0;
extern "C" {
/**
* @brief This function handles EXTI line3 interrupt.
*/
void EXTI0_IRQHandler() { HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_0); }
void EXTI1_IRQHandler() { HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_1); }
void EXTI2_IRQHandler() { HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_2); }
void EXTI3_IRQHandler() { HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_3); }
void EXTI4_IRQHandler() { HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_4); }
void EXTI9_5_IRQHandler(void) {
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_5);
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_6);
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_7);
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_8);
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_9);
}
void EXTI15_10_IRQHandler(void) {
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_10);
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_11);
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_12);
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_13);
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_14);
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_15);
}
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {
for (int i = 0; i < s_irqGPIO_num; i++) {
s_irqGPIO[i]->tryTriggerIRQ(GPIO_Pin);
}
}
}
void ZGPIO::regListener(onirq_t listener) { m_onirq = listener; }
/*******************************************************************************
* GPIOIMPL *
*******************************************************************************/
/*******************************************************************************
* BASE_FUNC *
*******************************************************************************/
bool ZGPIO::enableClock() {
#ifdef GPIOA
if (m_gpio == GPIOA) {
__HAL_RCC_GPIOA_CLK_ENABLE();
return true;
}
#endif
#ifdef GPIOB
if (m_gpio == GPIOB) {
__HAL_RCC_GPIOB_CLK_ENABLE();
return true;
}
#endif
#ifdef GPIOC
if (m_gpio == GPIOC) {
__HAL_RCC_GPIOC_CLK_ENABLE();
return true;
}
#endif
#ifdef GPIOD
if (m_gpio == GPIOD) {
__HAL_RCC_GPIOD_CLK_ENABLE();
return true;
}
#endif
#ifdef GPIOE
if (m_gpio == GPIOE) {
__HAL_RCC_GPIOE_CLK_ENABLE();
return true;
}
#endif
#ifdef GPIOF
if (m_gpio == GPIOF) {
__HAL_RCC_GPIOF_CLK_ENABLE();
return true;
}
#endif
#ifdef GPIOG
if (m_gpio == GPIOG) {
__HAL_RCC_GPIOG_CLK_ENABLE();
return true;
}
#endif
#ifdef GPIOH
if (m_gpio == GPIOH) {
__HAL_RCC_GPIOH_CLK_ENABLE();
return true;
}
#endif
#ifdef GPIOI
if (m_gpio == GPIOI) {
__HAL_RCC_GPIOI_CLK_ENABLE();
return true;
}
#endif
#ifdef GPIOJ
if (m_gpio == GPIOJ) {
__HAL_RCC_GPIOJ_CLK_ENABLE();
return true;
}
#endif
#ifdef GPIOK
if (m_gpio == GPIOK) {
__HAL_RCC_GPIOK_CLK_ENABLE();
return true;
}
#endif
return false;
}
void regIRQGPIO(ZGPIO *gpio) {
for (int i = 0; i < s_irqGPIO_num; i++) {
if (s_irqGPIO[i] == gpio) {
return;
}
}
EARLY_ASSERT((s_irqGPIO_num + 1) < (int)ZARRAY_SIZE(s_irqGPIO));
s_irqGPIO[s_irqGPIO_num] = gpio;
s_irqGPIO_num++;
}
bool ZGPIO::isMirror() { return m_mirror; }
void ZGPIO::initAsInput(Pin_t pin, GPIOMode_t mode, GPIOIrqType_t irqtype, bool mirror) {
if (pin == PinNull) return;
m_mirror = mirror;
m_mode = mode;
m_irqtype = irqtype;
m_gpiotype = kType_Input;
m_pin = pin;
m_gpio = stm32_get_gpio_group(pin);
m_pinoff = stm32_get_pinoff(pin);
uint32_t pulluptype = 0;
if (mode == kMode_nopull) {
pulluptype = GPIO_NOPULL;
} else if (mode == kMode_pullup) {
pulluptype = GPIO_PULLUP;
} else if (mode == kMode_pulldown) {
pulluptype = GPIO_PULLDOWN;
}
enableClock();
GPIO_InitTypeDef m_GPIO_InitStruct = {0};
if (m_irqtype == kIRQ_noIrq) {
m_GPIO_InitStruct.Pin = m_pinoff;
m_GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
m_GPIO_InitStruct.Pull = pulluptype;
m_GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
} else if (m_irqtype == kIRQ_risingIrq) {
m_GPIO_InitStruct.Pin = m_pinoff;
m_GPIO_InitStruct.Mode = m_mirror ? GPIO_MODE_IT_FALLING : GPIO_MODE_IT_RISING;
m_GPIO_InitStruct.Pull = pulluptype;
m_GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
} else if (m_irqtype == kIRQ_fallingIrq) {
m_GPIO_InitStruct.Pin = m_pinoff;
m_GPIO_InitStruct.Mode = !m_mirror ? GPIO_MODE_IT_FALLING : GPIO_MODE_IT_RISING;
m_GPIO_InitStruct.Pull = pulluptype;
m_GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
} else if (m_irqtype == kIRQ_risingAndFallingIrq) {
m_GPIO_InitStruct.Pin = m_pinoff;
m_GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING_FALLING;
m_GPIO_InitStruct.Pull = pulluptype;
m_GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
}
HAL_GPIO_Init(m_gpio, &m_GPIO_InitStruct);
if (m_irqtype != kIRQ_noIrq) {
regIRQGPIO(this);
lastLevel = getState();
HAL_NVIC_SetPriority(getEXTIIRQn(), PC_IRQ_PREEMPTPRIORITY_DEFAULT, 0);
HAL_NVIC_EnableIRQ(getEXTIIRQn());
}
m_initflag = true;
return;
}
void ZGPIO::initAsOutput(Pin_t pin, GPIOMode_t mode, bool mirror, bool initLevel) {
if (pin == PinNull) return;
m_mirror = mirror;
m_mode = mode;
m_irqtype = kIRQ_noIrq;
m_gpiotype = kType_Output;
m_pin = pin;
m_gpio = stm32_get_gpio_group(pin);
m_pinoff = stm32_get_pinoff(pin);
enableClock();
GPIO_InitTypeDef m_GPIO_InitStruct = {0};
initLevel = m_mirror ? !initLevel : initLevel;
GPIO_PinState pinState = initLevel ? GPIO_PIN_SET : GPIO_PIN_RESET;
HAL_GPIO_WritePin(m_gpio, m_pinoff, pinState);
if (m_mode == kMode_nopull) {
m_GPIO_InitStruct.Pin = m_pinoff;
m_GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
m_GPIO_InitStruct.Pull = GPIO_NOPULL;
m_GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
} else if (m_mode == kMode_pullup) {
m_GPIO_InitStruct.Pin = m_pinoff;
m_GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
m_GPIO_InitStruct.Pull = GPIO_PULLUP;
m_GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
} else if (m_mode == kMode_pulldown) {
m_GPIO_InitStruct.Pin = m_pinoff;
m_GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
m_GPIO_InitStruct.Pull = GPIO_PULLDOWN;
m_GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
} else if (m_mode == kMode_od) {
m_GPIO_InitStruct.Pin = m_pinoff;
m_GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;
m_GPIO_InitStruct.Pull = 0;
m_GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
}
HAL_GPIO_Init(m_gpio, &m_GPIO_InitStruct);
m_initflag = true;
return;
}
bool ZGPIO::isItRisingEXITGPIO() { return m_irqtype == kIRQ_risingIrq; }
bool ZGPIO::isItFallingEXITGPIO() { return m_irqtype == kIRQ_fallingIrq; }
bool ZGPIO::isItRisingAndItFallingEXITGPIO() { return m_irqtype == kIRQ_risingAndFallingIrq; }
/*******************************************************************************
* EXT FUNC *
*******************************************************************************/
/**
* @brief 判断当前是否是这个引脚产生的中断
*
* @param checkloop
* @param GPIO_Pin
* @return true
* @return false
*
* 由于STM32的GPIO中断线是共用的，所以需要根据GPIO的即时状态判断是否是这个引脚产生的中??
*
* 判断逻辑??:
* 先判断所有中断模式是 GPIO_MODE_IT_RISING ?? GPIO_MODE_IT_FALLING 的引脚，采样当前电平判断是否是这个引脚产生的中断
* 再判断中断模式是 GPIO_MODE_IT_RISING_FALLING 的引脚，直接返回true
*/
bool ZGPIO::tryTriggerIRQ(uint16_t GPIO_Pin) {
bool ret = false;
bool nostate = false;
if (GPIO_Pin != m_pinoff) return false;
if (!(isItRisingEXITGPIO() || isItFallingEXITGPIO() || isItRisingAndItFallingEXITGPIO())) {
return false;
}
nostate = getState();
if (isItRisingEXITGPIO()) {
if (nostate) {
ret = true;
if (m_onirq) {
m_onirq(this, kRisingIrqEvent);
}
}
} else if (isItFallingEXITGPIO()) {
if (!nostate) {
ret = true;
if (m_onirq) {
m_onirq(this, kFallingIrqEvent);
}
}
} else {
if (lastLevel != nostate) {
ret = true;
if (m_onirq) {
if (lastLevel)
m_onirq(this, kRisingIrqEvent);
else
m_onirq(this, kFallingIrqEvent);
}
}
}
lastLevel = nostate;
return ret;
}
void ZGPIO::toggleState() { HAL_GPIO_TogglePin(m_gpio, m_pinoff); }
uint32_t ZGPIO::getStateUint32() {
if (getState())
return 1;
else
return 0;
}
bool ZGPIO::getState() {
if (m_pin == PinNull) return false;
bool ret = false;
if (HAL_GPIO_ReadPin(m_gpio, m_pinoff) == GPIO_PIN_SET) {
ret = true;
} else {
ret = false;
}
if (m_mirror) ret = !ret;
return ret;
}
bool ZGPIO::setState(bool state) {
if (m_pin == PinNull) return true;
if (m_mirror) state = !state;
if (m_log_when_setstate) {
ZLOGI(TAG, "%s%s set %d", stm32_gpio_group_get_name(m_gpio), stm32_pinoff_get_name(m_pinoff), state);
}
if (state) {
HAL_GPIO_WritePin(m_gpio, m_pinoff, GPIO_PIN_SET);
} else {
HAL_GPIO_WritePin(m_gpio, m_pinoff, GPIO_PIN_RESET);
}
return true;
}
IRQn_Type ZGPIO::getEXTIIRQn() {
switch (m_pinoff) {
case GPIO_PIN_0:
return EXTI0_IRQn;
case GPIO_PIN_1:
return EXTI1_IRQn;
case GPIO_PIN_2:
return EXTI2_IRQn;
case GPIO_PIN_3:
return EXTI3_IRQn;
case GPIO_PIN_4:
return EXTI4_IRQn;
case GPIO_PIN_5:
case GPIO_PIN_6:
case GPIO_PIN_7:
case GPIO_PIN_8:
case GPIO_PIN_9:
return EXTI9_5_IRQn;
case GPIO_PIN_10:
case GPIO_PIN_11:
case GPIO_PIN_12:
case GPIO_PIN_13:
case GPIO_PIN_14:
case GPIO_PIN_15:
return EXTI15_10_IRQn;
default:
ZASSERT(0);
}
return EXTI0_IRQn;
}
/**
* @brief 初始化GPIO为中断模??
*
* @param pull GPIO_NOPULL, GPIO_PULLUP, GPIO_PULLDOWN
* @param mode GPIO_MODE_IT_RISING, GPIO_MODE_IT_FALLING, GPIO_MODE_IT_RISING_FALLING
* @return true
* @return false
*/
} // namespace iflytop
using namespace iflytop;
ZGPIO IO_PA0(PA0);
ZGPIO IO_PA1(PA1);
ZGPIO IO_PA2(PA2);
ZGPIO IO_PA3(PA3);
ZGPIO IO_PA4(PA4);
ZGPIO IO_PA5(PA5);
ZGPIO IO_PA6(PA6);
ZGPIO IO_PA7(PA7);
ZGPIO IO_PA8(PA8);
ZGPIO IO_PA9(PA9);
ZGPIO IO_PA10(PA10);
ZGPIO IO_PA11(PA11);
ZGPIO IO_PA12(PA12);
ZGPIO IO_PA13(PA13);
ZGPIO IO_PA14(PA14);
ZGPIO IO_PA15(PA15);
ZGPIO IO_PB0(PB0);
ZGPIO IO_PB1(PB1);
ZGPIO IO_PB2(PB2);
ZGPIO IO_PB3(PB3);
ZGPIO IO_PB4(PB4);
ZGPIO IO_PB5(PB5);
ZGPIO IO_PB6(PB6);
ZGPIO IO_PB7(PB7);
ZGPIO IO_PB8(PB8);
ZGPIO IO_PB9(PB9);
ZGPIO IO_PB10(PB10);
ZGPIO IO_PB11(PB11);
ZGPIO IO_PB12(PB12);
ZGPIO IO_PB13(PB13);
ZGPIO IO_PB14(PB14);
ZGPIO IO_PB15(PB15);
ZGPIO IO_PC0(PC0);
ZGPIO IO_PC1(PC1);
ZGPIO IO_PC2(PC2);
ZGPIO IO_PC3(PC3);
ZGPIO IO_PC4(PC4);
ZGPIO IO_PC5(PC5);
ZGPIO IO_PC6(PC6);
ZGPIO IO_PC7(PC7);
ZGPIO IO_PC8(PC8);
ZGPIO IO_PC9(PC9);
ZGPIO IO_PC10(PC10);
ZGPIO IO_PC11(PC11);
ZGPIO IO_PC12(PC12);
ZGPIO IO_PC13(PC13);
ZGPIO IO_PC14(PC14);
ZGPIO IO_PC15(PC15);
ZGPIO IO_PD0(PD0);
ZGPIO IO_PD1(PD1);
ZGPIO IO_PD2(PD2);
ZGPIO IO_PD3(PD3);
ZGPIO IO_PD4(PD4);
ZGPIO IO_PD5(PD5);
ZGPIO IO_PD6(PD6);
ZGPIO IO_PD7(PD7);
ZGPIO IO_PD8(PD8);
ZGPIO IO_PD9(PD9);
ZGPIO IO_PD10(PD10);
ZGPIO IO_PD11(PD11);
ZGPIO IO_PD12(PD12);
ZGPIO IO_PD13(PD13);
ZGPIO IO_PD14(PD14);
ZGPIO IO_PD15(PD15);
ZGPIO IO_PE0(PE0);
ZGPIO IO_PE1(PE1);
ZGPIO IO_PE2(PE2);
ZGPIO IO_PE3(PE3);
ZGPIO IO_PE4(PE4);
ZGPIO IO_PE5(PE5);
ZGPIO IO_PE6(PE6);
ZGPIO IO_PE7(PE7);
ZGPIO IO_PE8(PE8);
ZGPIO IO_PE9(PE9);
ZGPIO IO_PE10(PE10);
ZGPIO IO_PE11(PE11);
ZGPIO IO_PE12(PE12);
ZGPIO IO_PE13(PE13);
ZGPIO IO_PE14(PE14);
ZGPIO IO_PE15(PE15);
ZGPIO IO_PF0(PF0);
ZGPIO IO_PF1(PF1);
ZGPIO IO_PF2(PF2);
ZGPIO IO_PF3(PF3);
ZGPIO IO_PF4(PF4);
ZGPIO IO_PF5(PF5);
ZGPIO IO_PF6(PF6);
ZGPIO IO_PF7(PF7);
ZGPIO IO_PF8(PF8);
ZGPIO IO_PF9(PF9);
ZGPIO IO_PF10(PF10);
ZGPIO IO_PF11(PF11);
ZGPIO IO_PF12(PF12);
ZGPIO IO_PF13(PF13);
ZGPIO IO_PF14(PF14);
ZGPIO IO_PF15(PF15);
ZGPIO IO_PG0(PG0);
ZGPIO IO_PG1(PG1);
ZGPIO IO_PG2(PG2);
ZGPIO IO_PG3(PG3);
ZGPIO IO_PG4(PG4);
ZGPIO IO_PG5(PG5);
ZGPIO IO_PG6(PG6);
ZGPIO IO_PG7(PG7);
ZGPIO IO_PG8(PG8);
ZGPIO IO_PG9(PG9);
ZGPIO IO_PG10(PG10);
ZGPIO IO_PG11(PG11);
ZGPIO IO_PG12(PG12);
ZGPIO IO_PG13(PG13);
ZGPIO IO_PG14(PG14);
ZGPIO IO_PG15(PG15);