diff --git a/src/driver/drv_bl0937.c b/src/driver/drv_bl0937.c index 42181f191..6731ac29d 100644 --- a/src/driver/drv_bl0937.c +++ b/src/driver/drv_bl0937.c @@ -1,7 +1,370 @@ +// HLW8012 aka BL0937 #include "drv_bl0937.h" #include "../obk_config.h" + +#include "../hal/hal_pins.h" +#include "../new_pins.h" + +OBKInterruptHandler g_handlers[PLATFORM_GPIO_MAX]; +OBKInterruptType g_modes[PLATFORM_GPIO_MAX]; + +#if PLATFORM_BEKEN + +#include "BkDriverTimer.h" +#include "BkDriverGpio.h" +#include "sys_timer.h" +#include "gw_intf.h" + +void Beken_Interrupt(unsigned char pinNum) { + if (g_handlers[pinNum]) { + g_handlers[pinNum](pinNum); + } +} + +void HAL_AttachInterrupt(int pinIndex, OBKInterruptType mode, OBKInterruptHandler function) { + g_handlers[pinIndex] = function; + int bk_mode; + if (mode == INTERRUPT_RISING) { + bk_mode = IRQ_TRIGGER_RISING_EDGE; + } + else { + bk_mode = IRQ_TRIGGER_FALLING_EDGE; + } + gpio_int_enable(pinIndex, bk_mode, Beken_Interrupt); +} +void HAL_DetachInterrupt(int pinIndex) { + if (g_handlers[pinIndex] == 0) { + return; // already removed; + } + gpio_int_disable(pinIndex); + g_handlers[pinIndex] = 0; +} + +#elif PLATFORM_W600 || PLATFORM_W800 + +void W600_Interrupt(void* context) { + int obkPinNum = (int)(intptr_t)context; + int w600Pin = HAL_GetGPIOPin(obkPinNum); + tls_clr_gpio_irq_status(w600Pin); + if (g_handlers[obkPinNum]) { + g_handlers[obkPinNum](obkPinNum); + } +} + +void HAL_AttachInterrupt(int pinIndex, OBKInterruptType mode, OBKInterruptHandler function) { + g_handlers[pinIndex] = function; + int w600Pin = HAL_GetGPIOPin(pinIndex); + tls_gpio_isr_register(w600Pin, W600_Interrupt, (void*)(intptr_t)pinIndex); + int w_mode; + if (mode == INTERRUPT_RISING) { + w_mode = WM_GPIO_IRQ_TRIG_RISING_EDGE; + } + else { + w_mode = WM_GPIO_IRQ_TRIG_FALLING_EDGE; + } + tls_gpio_irq_enable(w600Pin, w_mode); +} +void HAL_DetachInterrupt(int pinIndex) { + if (g_handlers[pinIndex] == 0) { + return; // already removed; + } + int w600Pin = HAL_GetGPIOPin(pinIndex); + tls_gpio_irq_disable(w600Pin); + g_handlers[pinIndex] = 0; +} + + + +#elif PLATFORM_BL602 + +#include "hal_gpio.h" +#include "bl_gpio.h" + +void BL602_Interrupt(void* context) { + int obkPinNum = (int)context; + if (g_handlers[obkPinNum]) { + g_handlers[obkPinNum](obkPinNum); + } + bl_gpio_intmask(obkPinNum, 0); +} + +void HAL_AttachInterrupt(int pinIndex, OBKInterruptType mode, OBKInterruptHandler function) { + g_handlers[pinIndex] = function; + int bl_mode; + if (mode == INTERRUPT_RISING) { + bl_mode = GPIO_INT_TRIG_POS_PULSE; + } + else { + bl_mode = GPIO_INT_TRIG_NEG_PULSE; + } + hal_gpio_register_handler(BL602_Interrupt, pinIndex, + GPIO_INT_CONTROL_ASYNC, bl_mode, (void*)pinIndex); +} +void HAL_DetachInterrupt(int pinIndex) { + if (g_handlers[pinIndex] == 0) { + return; // already removed; + } + g_handlers[pinIndex] = 0; +} + +#elif PLATFORM_LN882H + +#include "../../sdk/OpenLN882H/mcu/driver_ln882h/hal/hal_common.h" +#include "../../sdk/OpenLN882H/mcu/driver_ln882h/hal/hal_gpio.h" + +uint32_t GetBaseForPin(int pinIndex) +{ + return pinIndex < 16 ? GPIOA_BASE : GPIOB_BASE; +} + +int GetIRQForPin(int pinIndex) +{ + return pinIndex < 16 ? GPIOA_IRQn : GPIOB_IRQn; +} + +uint16_t GetGPIOForPin(int pinIndex) +{ + return (uint16_t)1 << (uint16_t)(pinIndex % 16); +} +void Shared_Handler() { + for (int i = 0; i < PLATFORM_GPIO_MAX; i++) { + if (g_handlers[i]) { + uint32_t base = GetBaseForPin(i); + uint16_t gpio_pin = GetGPIOForPin(i); + if (hal_gpio_pin_get_it_flag(base, gpio_pin) == HAL_SET) { + hal_gpio_pin_clr_it_flag(base, gpio_pin); + g_handlers[i](i); + } + } + } +} +void GPIOA_IRQHandler() +{ + Shared_Handler(); +} + +void GPIOB_IRQHandler() +{ + Shared_Handler(); +} + +void HAL_AttachInterrupt(int pinIndex, OBKInterruptType mode, OBKInterruptHandler function) { + g_handlers[pinIndex] = function; + + int ln_mode; + if (mode == INTERRUPT_RISING) { + ln_mode = GPIO_INT_RISING; + } + else { + ln_mode = GPIO_INT_FALLING; + } + hal_gpio_pin_it_cfg(GetBaseForPin(pinIndex), GetGPIOForPin(pinIndex), ln_mode); + hal_gpio_pin_it_en(GetBaseForPin(pinIndex), GetGPIOForPin(pinIndex), HAL_ENABLE); + NVIC_SetPriority(GetIRQForPin(pinIndex), 1); + NVIC_EnableIRQ(GetIRQForPin(pinIndex)); + +} + +void HAL_DetachInterrupt(int pinIndex) { + if (g_handlers[pinIndex] == 0) { + return; // already removed; + } + g_handlers[pinIndex] = 0; +} + +#elif PLATFORM_REALTEK + +#include "gpio_irq_api.h" +#include "../hal/realtek/hal_pinmap_realtek.h" + + +void Realtek_Interrupt(uint32_t obkPinNum, gpio_irq_event event) +{ + if (g_handlers[obkPinNum]) { + g_handlers[obkPinNum](obkPinNum); + } +} + +void HAL_AttachInterrupt(int pinIndex, OBKInterruptType mode, OBKInterruptHandler function) { + g_handlers[pinIndex] = function; + + rtlPinMapping_t *rtl_cf = g_pins + pinIndex; +#if PLATFORM_RTL87X0C + if (rtl_cf->gpio != NULL) + { + hal_pinmux_unregister(rtl_cf->pin, PID_GPIO); + os_free(rtl_cf->gpio); + rtl_cf->gpio = NULL; + } +#endif + rtl_cf->irq = os_malloc(sizeof(gpio_irq_t)); + memset(rtl_cf->irq, 0, sizeof(gpio_irq_t)); + + int rtl_mode; + if (mode == INTERRUPT_RISING) { + rtl_mode = IRQ_RISE; + } + else { + rtl_mode = IRQ_FALL; + } + gpio_irq_init(rtl_cf->irq, rtl_cf->pin, Realtek_Interrupt, pinIndex); + gpio_irq_set(rtl_cf->irq, rtl_mode, 1); + gpio_irq_enable(rtl_cf->irq); + +} +void HAL_DetachInterrupt(int pinIndex) { + if (g_handlers[pinIndex] == 0) { + return; // already removed; + } + rtlPinMapping_t *rtl_cf = g_pins + pinIndex; + gpio_irq_free(rtl_cf->irq); + os_free(rtl_cf->irq); + rtl_cf->irq = NULL; + g_handlers[pinIndex] = 0; +} + + +#elif PLATFORM_ECR6600 + +#include "gpio.h" + +void ECR6600_Interrupt(unsigned char obkPinNum) { + if (g_handlers[obkPinNum]) { + g_handlers[obkPinNum](obkPinNum); + } +} + +void HAL_AttachInterrupt(int pinIndex, OBKInterruptType mode, OBKInterruptHandler function) { + g_handlers[pinIndex] = function; + + T_GPIO_ISR_CALLBACK cf1isr; + cf1isr.gpio_callback = (&ECR6600_Interrupt); + cf1isr.gpio_data = pinIndex; + + int ecr_mode; + if (mode == INTERRUPT_RISING) { + ecr_mode = DRV_GPIO_ARG_INTR_MODE_P_EDGE; + } + else { + ecr_mode = DRV_GPIO_ARG_INTR_MODE_N_EDGE; + } + drv_gpio_ioctrl(pinIndex, DRV_GPIO_CTRL_INTR_MODE, ecr_mode); + drv_gpio_ioctrl(pinIndex, DRV_GPIO_CTRL_REGISTER_ISR, (int)&cf1isr); + drv_gpio_ioctrl(pinIndex, DRV_GPIO_CTRL_INTR_ENABLE, 0); + +} +void HAL_DetachInterrupt(int pinIndex) { + if (g_handlers[pinIndex] == 0) { + return; // already removed; + } + + drv_gpio_ioctrl(pinIndex, DRV_GPIO_CTRL_INTR_DISABLE, 0); + g_handlers[pinIndex] = 0; +} + + +#elif PLATFORM_XRADIO + +#include "../hal/xradio/hal_pinmap_xradio.h" +extern void HAL_XR_ConfigurePin(GPIO_Port port, GPIO_Pin pin, GPIO_WorkMode mode, GPIO_PullType pull); + + +void XRadio_Interrupt(void* context) { + int obkPinNum = (int)context; + if (g_handlers[obkPinNum]) { + g_handlers[obkPinNum](obkPinNum); + } +} + +void HAL_AttachInterrupt(int pinIndex, OBKInterruptType mode, OBKInterruptHandler function) { + g_handlers[pinIndex] = function; + + xrpin_t *xr_cf = g_pins + pinIndex; + HAL_XR_ConfigurePin(xr_cf->port, xr_cf->pin, GPIOx_Pn_F6_EINT, GPIO_PULL_UP); + GPIO_IrqParam cfparam; + int xr_mode; + if (mode == INTERRUPT_RISING) { + xr_mode = GPIO_IRQ_EVT_RISING_EDGE; + } + else { + xr_mode = GPIO_IRQ_EVT_FALLING_EDGE; + } + cfparam.event = xr_mode; + cfparam.callback = XRadio_Interrupt; + cfparam.arg = (void*)pinIndex; + HAL_GPIO_EnableIRQ(xr_cf->port, xr_cf->pin, &cfparam); + +} +void HAL_DetachInterrupt(int pinIndex) { + if (g_handlers[pinIndex] == 0) { + return; // already removed; + } + xrpin_t* xr_cf; + xr_cf = g_pins + pinIndex; + HAL_GPIO_DeInit(xr_cf->port, xr_cf->pin); + HAL_GPIO_DisableIRQ(xr_cf->port, xr_cf->pin); + g_handlers[pinIndex] = 0; +} + +#elif PLATFORM_ESP8266 || PLATFORM_ESPIDF + +#include "../hal/espidf/hal_pinmap_espidf.h" + + +void ESP_Interrupt(void* context) { + int obkPinNum = (int)context; + if (g_handlers[obkPinNum]) { + g_handlers[obkPinNum](obkPinNum); + } +} + +bool b_esp_ready = false; +void HAL_AttachInterrupt(int pinIndex, OBKInterruptType mode, OBKInterruptHandler function) { + g_handlers[pinIndex] = function; + + if (b_esp_ready == false) { + gpio_install_isr_service(0); + b_esp_ready = true; + } + espPinMapping_t* esp_cf = g_pins + pinIndex; + int esp_mode; + if (mode == INTERRUPT_RISING) { + esp_mode = GPIO_INTR_POSEDGE; + } + else { + esp_mode = GPIO_INTR_NEGEDGE; + } + ESP_ConfigurePin(esp_cf->pin, GPIO_MODE_INPUT, true, false, esp_mode); + gpio_isr_handler_add(esp_cf->pin, ESP_Interrupt, (void*)pinIndex); +} +void HAL_DetachInterrupt(int pinIndex) { + if (g_handlers[pinIndex] == 0) { + return; // already removed; + } + + espPinMapping_t* esp_cf; + esp_cf = g_pins + pinIndex; + gpio_isr_handler_remove(esp_cf->pin); + ///gpio_uninstall_isr_service(); + g_handlers[pinIndex] = 0; +} + + +#else +void HAL_AttachInterrupt(int pinIndex, OBKInterruptType mode, OBKInterruptHandler function) { + +} +void HAL_DetachInterrupt(int pinIndex) { + +} + + +#endif + + + #if ENABLE_DRIVER_BL0937 //dummy @@ -16,56 +379,9 @@ #include "drv_pwrCal.h" #include "drv_uart.h" -#if PLATFORM_BEKEN - -#include "BkDriverTimer.h" -#include "BkDriverGpio.h" -#include "sys_timer.h" -#include "gw_intf.h" - -// HLW8012 aka BL0937 - -#define ELE_HW_TIME 1 -#define HW_TIMER_ID 0 - -#elif PLATFORM_BL602 - -#include "hal_gpio.h" -#include "bl_gpio.h" - -#elif PLATFORM_LN882H - -#include "../../sdk/OpenLN882H/mcu/driver_ln882h/hal/hal_common.h" -#include "../../sdk/OpenLN882H/mcu/driver_ln882h/hal/hal_gpio.h" - -#elif PLATFORM_REALTEK - -#include "gpio_irq_api.h" -#include "../hal/realtek/hal_pinmap_realtek.h" -rtlPinMapping_t* rtl_cf; -rtlPinMapping_t* rtl_cf1; - -#elif PLATFORM_ECR6600 - -#include "gpio.h" - -#elif PLATFORM_XRADIO - -#include "../hal/xradio/hal_pinmap_xradio.h" -extern void HAL_XR_ConfigurePin(GPIO_Port port, GPIO_Pin pin, GPIO_WorkMode mode, GPIO_PullType pull); -xrpin_t* xr_cf; -xrpin_t* xr_cf1; - -#elif PLATFORM_ESP8266 || PLATFORM_ESPIDF - -#include "../hal/espidf/hal_pinmap_espidf.h" -espPinMapping_t* esp_cf; -espPinMapping_t* esp_cf1; - -#else -#endif + #define DEFAULT_VOLTAGE_CAL 0.13253012048f #define DEFAULT_CURRENT_CAL 0.0118577075f @@ -78,12 +394,6 @@ bool g_invertSEL = false; int GPIO_HLW_CF = 7; int GPIO_HLW_CF1 = 8; -#if PLATFORM_W600 -//The above three actually are pin indices. For W600 the actual gpio_pins are different. -unsigned int GPIO_HLW_CF_pin; -unsigned int GPIO_HLW_CF1_pin; -#endif - bool g_sel = true; uint32_t res_v = 0; uint32_t res_c = 0; @@ -95,125 +405,16 @@ volatile uint32_t g_vc_pulses = 0; volatile uint32_t g_p_pulses = 0; static portTickType pulseStamp; -#if PLATFORM_W600 -static void HlwCf1Interrupt(void* context) -{ - tls_clr_gpio_irq_status(GPIO_HLW_CF1_pin); - g_vc_pulses++; -} -static void HlwCfInterrupt(void* context) -{ - tls_clr_gpio_irq_status(GPIO_HLW_CF_pin); - g_p_pulses++; -} - -#elif PLATFORM_BL602 - -static void HlwCf1Interrupt(void* arg) -{ - g_vc_pulses++; - bl_gpio_intmask(GPIO_HLW_CF1, 0); -} -static void HlwCfInterrupt(void* arg) -{ - g_p_pulses++; - bl_gpio_intmask(GPIO_HLW_CF, 0); -} - -#elif PLATFORM_LN882H - -uint32_t GetBaseForPin(int pinIndex) -{ - return pinIndex < 16 ? GPIOA_BASE : GPIOB_BASE; -} - -int GetIRQForPin(int pinIndex) -{ - return pinIndex < 16 ? GPIOA_IRQn : GPIOB_IRQn; -} - -uint16_t GetGPIOForPin(int pinIndex) -{ - return (uint16_t)1 << (uint16_t)(pinIndex % 16); -} - -void GPIOA_IRQHandler() -{ - uint32_t base = GetBaseForPin(GPIO_HLW_CF1); - uint16_t gpio_pin = GetGPIOForPin(GPIO_HLW_CF1); - if(hal_gpio_pin_get_it_flag(base, gpio_pin) == HAL_SET) - { - hal_gpio_pin_clr_it_flag(base, gpio_pin); - g_vc_pulses++; - } - - base = GetBaseForPin(GPIO_HLW_CF); - gpio_pin = GetGPIOForPin(GPIO_HLW_CF); - if(hal_gpio_pin_get_it_flag(base, gpio_pin) == HAL_SET) - { - hal_gpio_pin_clr_it_flag(base, gpio_pin); - g_p_pulses++; - } -} - -void GPIOB_IRQHandler() -{ - uint32_t base = GetBaseForPin(GPIO_HLW_CF1); - uint16_t gpio_pin = GetGPIOForPin(GPIO_HLW_CF1); - if(hal_gpio_pin_get_it_flag(base, gpio_pin) == HAL_SET) - { - hal_gpio_pin_clr_it_flag(base, gpio_pin); - g_vc_pulses++; - } - - base = GetBaseForPin(GPIO_HLW_CF); - gpio_pin = GetGPIOForPin(GPIO_HLW_CF); - if(hal_gpio_pin_get_it_flag(base, gpio_pin) == HAL_SET) - { - hal_gpio_pin_clr_it_flag(base, gpio_pin); - g_p_pulses++; - } -} - -#elif PLATFORM_REALTEK - -void cf_irq_handler(uint32_t id, gpio_irq_event event) -{ - g_p_pulses++; -} - -void cf1_irq_handler(uint32_t id, gpio_irq_event event) +void HlwCf1Interrupt(int pinNum) { g_vc_pulses++; } - -#elif PLATFORM_XRADIO || PLATFORM_ESPIDF || PLATFORM_ESP8266 - -static void HlwCf1Interrupt(void* arg) -{ - g_vc_pulses++; -} -static void HlwCfInterrupt(void* arg) +void HlwCfInterrupt(int pinNum) { g_p_pulses++; } -#else - -void HlwCf1Interrupt(unsigned char pinNum) -{ - // Service Voltage and Current - g_vc_pulses++; -} -void HlwCfInterrupt(unsigned char pinNum) -{ - // Service Power - g_p_pulses++; -} - -#endif - commandResult_t BL0937_PowerMax(const void* context, const char* cmd, const char* args, int cmdFlags) { float maxPower; @@ -240,46 +441,8 @@ commandResult_t BL0937_PowerMax(const void* context, const char* cmd, const char void BL0937_Shutdown_Pins() { -#if PLATFORM_W600 - - tls_gpio_irq_disable(GPIO_HLW_CF1_pin); - tls_gpio_irq_disable(GPIO_HLW_CF_pin); - -#elif PLATFORM_BL602 - //Todo how? -#elif PLATFORM_BEKEN - - gpio_int_disable(GPIO_HLW_CF1); - gpio_int_disable(GPIO_HLW_CF); - -#elif PLATFORM_REALTEK - - gpio_irq_free(rtl_cf1->irq); - gpio_irq_free(rtl_cf->irq); - os_free(rtl_cf1->irq); - os_free(rtl_cf->irq); - rtl_cf1->irq = NULL; - rtl_cf->irq = NULL; - -#elif PLATFORM_ECR6600 - - drv_gpio_ioctrl(GPIO_HLW_CF1, DRV_GPIO_CTRL_INTR_DISABLE, 0); - drv_gpio_ioctrl(GPIO_HLW_CF, DRV_GPIO_CTRL_INTR_DISABLE, 0); - -#elif PLATFORM_XRADIO - - HAL_GPIO_DeInit(xr_cf->port, xr_cf->pin); - HAL_GPIO_DisableIRQ(xr_cf->port, xr_cf->pin); - HAL_GPIO_DeInit(xr_cf1->port, xr_cf1->pin); - HAL_GPIO_DisableIRQ(xr_cf1->port, xr_cf1->pin); - -#elif PLATFORM_ESPIDF || PLATFORM_ESP8266 - - gpio_isr_handler_remove(esp_cf->pin); - gpio_isr_handler_remove(esp_cf1->pin); - gpio_uninstall_isr_service(); - -#endif + HAL_DetachInterrupt(GPIO_HLW_CF); + HAL_DetachInterrupt(GPIO_HLW_CF1); } void BL0937_Init_Pins() @@ -301,163 +464,16 @@ void BL0937_Init_Pins() GPIO_HLW_CF = PIN_FindPinIndexForRole(IOR_BL0937_CF, GPIO_HLW_CF); GPIO_HLW_CF1 = PIN_FindPinIndexForRole(IOR_BL0937_CF1, GPIO_HLW_CF1); -#if PLATFORM_W600 - - GPIO_HLW_CF1_pin = HAL_GetGPIOPin(GPIO_HLW_CF1); - GPIO_HLW_CF_pin = HAL_GetGPIOPin(GPIO_HLW_CF); - //printf("GPIO_HLW_CF=%d GPIO_HLW_CF1=%d\n", GPIO_HLW_CF, GPIO_HLW_CF1); - //printf("GPIO_HLW_CF1_pin=%d GPIO_HLW_CF_pin=%d\n", GPIO_HLW_CF1_pin, GPIO_HLW_CF_pin); - -#elif PLATFORM_REALTEK - - rtl_cf = g_pins + GPIO_HLW_CF; - rtl_cf1 = g_pins + GPIO_HLW_CF1; -#if PLATFORM_RTL87X0C - if(rtl_cf->gpio != NULL) - { - hal_pinmux_unregister(rtl_cf->pin, PID_GPIO); - os_free(rtl_cf->gpio); - rtl_cf->gpio = NULL; - } - if(rtl_cf1->gpio != NULL) - { - hal_pinmux_unregister(rtl_cf1->pin, PID_GPIO); - os_free(rtl_cf1->gpio); - rtl_cf1->gpio = NULL; - } -#endif - rtl_cf1->irq = os_malloc(sizeof(gpio_irq_t)); - rtl_cf->irq = os_malloc(sizeof(gpio_irq_t)); - memset(rtl_cf1->irq, 0, sizeof(gpio_irq_t)); - memset(rtl_cf->irq, 0, sizeof(gpio_irq_t)); - -#elif PLATFORM_XRADIO - - xr_cf = g_pins + GPIO_HLW_CF; - xr_cf1 = g_pins + GPIO_HLW_CF1; - -#elif PLATFORM_ESPIDF || PLATFORM_ESP8266 - - esp_cf = g_pins + GPIO_HLW_CF; - esp_cf1 = g_pins + GPIO_HLW_CF1; - gpio_install_isr_service(0); - -#endif - BL0937_PMAX = CFG_GetPowerMeasurementCalibrationFloat(CFG_OBK_POWER_MAX, BL0937_PMAX); HAL_PIN_Setup_Output(GPIO_HLW_SEL); HAL_PIN_SetOutputValue(GPIO_HLW_SEL, g_sel); HAL_PIN_Setup_Input_Pullup(GPIO_HLW_CF1); - -#if PLATFORM_W600 - - tls_gpio_isr_register(GPIO_HLW_CF1_pin, HlwCf1Interrupt, NULL); - tls_gpio_irq_enable(GPIO_HLW_CF1_pin, WM_GPIO_IRQ_TRIG_FALLING_EDGE); - -#elif PLATFORM_BL602 - - tmp = hal_gpio_register_handler(HlwCf1Interrupt, GPIO_HLW_CF1, GPIO_INT_CONTROL_ASYNC, GPIO_INT_TRIG_NEG_PULSE, (void*)NULL); - addLogAdv(LOG_INFO, LOG_FEATURE_ENERGYMETER, "Registering CF1 handler status: %i \n", tmp); - -#elif PLATFORM_LN882H - - hal_gpio_pin_it_cfg(GetBaseForPin(GPIO_HLW_CF1), GetGPIOForPin(GPIO_HLW_CF1), GPIO_INT_FALLING); - hal_gpio_pin_it_en(GetBaseForPin(GPIO_HLW_CF1), GetGPIOForPin(GPIO_HLW_CF1), HAL_ENABLE); - NVIC_SetPriority(GetIRQForPin(GPIO_HLW_CF1), 1); - NVIC_EnableIRQ(GetIRQForPin(GPIO_HLW_CF1)); - -#elif PLATFORM_BEKEN - - gpio_int_enable(GPIO_HLW_CF1, IRQ_TRIGGER_FALLING_EDGE, HlwCf1Interrupt); - -#elif PLATFORM_REALTEK - - gpio_irq_init(rtl_cf1->irq, rtl_cf1->pin, cf1_irq_handler, NULL); - gpio_irq_set(rtl_cf1->irq, IRQ_FALL, 1); - gpio_irq_enable(rtl_cf1->irq); - -#elif PLATFORM_ECR6600 - - T_GPIO_ISR_CALLBACK cf1isr; - cf1isr.gpio_callback = (&HlwCf1Interrupt); - cf1isr.gpio_data = 0; - - drv_gpio_ioctrl(GPIO_HLW_CF1, DRV_GPIO_CTRL_INTR_MODE, DRV_GPIO_ARG_INTR_MODE_N_EDGE); - drv_gpio_ioctrl(GPIO_HLW_CF1, DRV_GPIO_CTRL_REGISTER_ISR, (int)&cf1isr); - drv_gpio_ioctrl(GPIO_HLW_CF1, DRV_GPIO_CTRL_INTR_ENABLE, 0); - -#elif PLATFORM_XRADIO - - HAL_XR_ConfigurePin(xr_cf1->port, xr_cf1->pin, GPIOx_Pn_F6_EINT, GPIO_PULL_UP); - GPIO_IrqParam cf1param; - cf1param.event = GPIO_IRQ_EVT_FALLING_EDGE; - cf1param.callback = HlwCf1Interrupt; - cf1param.arg = (void*)0; - HAL_GPIO_EnableIRQ(xr_cf1->port, xr_cf1->pin, &cf1param); - -#elif PLATFORM_ESPIDF || PLATFORM_ESP8266 - - ESP_ConfigurePin(esp_cf1->pin, GPIO_MODE_INPUT, true, false, GPIO_INTR_NEGEDGE); - gpio_isr_handler_add(esp_cf1->pin, HlwCf1Interrupt, NULL); - -#endif - HAL_PIN_Setup_Input_Pullup(GPIO_HLW_CF); -#if PLATFORM_W600 - - tls_gpio_isr_register(GPIO_HLW_CF_pin, HlwCfInterrupt, NULL); - tls_gpio_irq_enable(GPIO_HLW_CF_pin, WM_GPIO_IRQ_TRIG_FALLING_EDGE); - -#elif PLATFORM_BL602 - - tmp = hal_gpio_register_handler(HlwCfInterrupt, GPIO_HLW_CF, GPIO_INT_CONTROL_ASYNC, GPIO_INT_TRIG_NEG_PULSE, (void*)NULL); - addLogAdv(LOG_INFO, LOG_FEATURE_ENERGYMETER, "Registering CF handler status: %i \n", tmp); - -#elif PLATFORM_LN882H - - hal_gpio_pin_it_cfg(GetBaseForPin(GPIO_HLW_CF), GetGPIOForPin(GPIO_HLW_CF), GPIO_INT_FALLING); - hal_gpio_pin_it_en(GetBaseForPin(GPIO_HLW_CF), GetGPIOForPin(GPIO_HLW_CF), HAL_ENABLE); - NVIC_SetPriority(GetIRQForPin(GPIO_HLW_CF), 1); - NVIC_EnableIRQ(GetIRQForPin(GPIO_HLW_CF)); - -#elif PLATFORM_BEKEN - - gpio_int_enable(GPIO_HLW_CF, IRQ_TRIGGER_FALLING_EDGE, HlwCfInterrupt); - -#elif PLATFORM_REALTEK - - gpio_irq_init(rtl_cf->irq, rtl_cf->pin, cf_irq_handler, NULL); - gpio_irq_set(rtl_cf->irq, IRQ_FALL, 1); - gpio_irq_enable(rtl_cf->irq); - -#elif PLATFORM_ECR6600 - - T_GPIO_ISR_CALLBACK cfisr; - cfisr.gpio_callback = (&HlwCfInterrupt); - cfisr.gpio_data = 0; - - drv_gpio_ioctrl(GPIO_HLW_CF, DRV_GPIO_CTRL_INTR_MODE, DRV_GPIO_ARG_INTR_MODE_N_EDGE); - drv_gpio_ioctrl(GPIO_HLW_CF, DRV_GPIO_CTRL_REGISTER_ISR, (int)&cfisr); - drv_gpio_ioctrl(GPIO_HLW_CF, DRV_GPIO_CTRL_INTR_ENABLE, 0); - -#elif PLATFORM_XRADIO - - HAL_XR_ConfigurePin(xr_cf->port, xr_cf->pin, GPIOx_Pn_F6_EINT, GPIO_PULL_UP); - GPIO_IrqParam cfparam; - cfparam.event = GPIO_IRQ_EVT_FALLING_EDGE; - cfparam.callback = HlwCfInterrupt; - cfparam.arg = (void*)0; - HAL_GPIO_EnableIRQ(xr_cf->port, xr_cf->pin, &cfparam); - -#elif PLATFORM_ESPIDF || PLATFORM_ESP8266 - - ESP_ConfigurePin(esp_cf->pin, GPIO_MODE_INPUT, true, false, GPIO_INTR_NEGEDGE); - gpio_isr_handler_add(esp_cf->pin, HlwCfInterrupt, NULL); - -#endif + HAL_AttachInterrupt(GPIO_HLW_CF, INTERRUPT_STUB, HlwCfInterrupt); + HAL_AttachInterrupt(GPIO_HLW_CF1, INTERRUPT_STUB, HlwCf1Interrupt); g_vc_pulses = 0; g_p_pulses = 0; diff --git a/src/hal/hal_pins.h b/src/hal/hal_pins.h index d279ea346..143361a24 100644 --- a/src/hal/hal_pins.h +++ b/src/hal/hal_pins.h @@ -1,4 +1,7 @@ +#ifndef __HAL_OBK_PINS_H__ +#define __HAL_OBK_PINS_H__ + void HAL_PIN_SetOutputValue(int index, int iVal); int HAL_PIN_ReadDigitalInput(int index); void HAL_PIN_Setup_Input_Pulldown(int index); @@ -14,7 +17,21 @@ const char* HAL_PIN_GetPinNameAlias(int index); // Translate name like RB5 for OBK pin index int HAL_PIN_Find(const char *name); +typedef void(*OBKInterruptHandler)(int gpio); +typedef enum { + INTERRUPT_STUB, + INTERRUPT_RISING, + INTERRUPT_FALLING, + INTERRUPT_CHANGE, + +} OBKInterruptType; +void HAL_AttachInterrupt(int pinIndex, OBKInterruptType mode, OBKInterruptHandler function); +void HAL_DetachInterrupt(int pinIndex); + /// @brief Get the actual GPIO pin for the pin index. /// @param index /// @return unsigned int HAL_GetGPIOPin(int index); + +#endif + diff --git a/src/httpserver/new_http.c b/src/httpserver/new_http.c index 312825862..8a7697238 100644 --- a/src/httpserver/new_http.c +++ b/src/httpserver/new_http.c @@ -552,7 +552,8 @@ const char* htmlPinRoleNames[] = { "DS1820_IO", "PWM_ScriptOnly", "PWM_ScriptOnly_n", - "error", + "Counter_f", + "Counter_r", "error", "error", "error", diff --git a/src/new_pins.c b/src/new_pins.c index 338635aa3..680018bd4 100644 --- a/src/new_pins.c +++ b/src/new_pins.c @@ -887,6 +887,34 @@ void CHANNEL_DoSpecialToggleAll() { } extern int g_pwmFrequency; +#if 0 +void PIN_InterruptHandler(int gpio) { + int ch = g_cfg.pins.channels[gpio]; + CHANNEL_Add(ch, 1); +} +#else + + +#endif + +unsigned short g_counterDeltas[PLATFORM_GPIO_MAX]; +void PIN_InterruptHandler(int gpio) { + g_counterDeltas[gpio]++; +} +void PIN_ApplyCounterDeltas() { + for (int i = 0; i < PLATFORM_GPIO_MAX; i++) { + if (g_counterDeltas[i]) { + // TODO: disable interrupts now so it won't get called in meantime? + int delta = g_counterDeltas[i]; + g_counterDeltas[i] = 0; + int ch = g_cfg.pins.channels[i]; + CHANNEL_Add(ch, delta); + } + } +} + + + void PIN_SetPinRoleForPinIndex(int index, int role) { bool bDHTChange = false; bool bSampleInitialState = false; @@ -961,6 +989,10 @@ void PIN_SetPinRoleForPinIndex(int index, int role) { case IOR_ADC: HAL_ADC_Deinit(index); break; + case IOR_Counter_f: + case IOR_Counter_r: + HAL_DetachInterrupt(index); + break; case IOR_BridgeForward: case IOR_BridgeReverse: break; @@ -1150,6 +1182,14 @@ void PIN_SetPinRoleForPinIndex(int index, int role) { #else HAL_ADC_Init(index); #endif + break; + case IOR_Counter_f: + HAL_PIN_Setup_Input_Pullup(index); + HAL_AttachInterrupt(index, INTERRUPT_FALLING, PIN_InterruptHandler); + break; + case IOR_Counter_r: + HAL_PIN_Setup_Input_Pullup(index); + HAL_AttachInterrupt(index, INTERRUPT_RISING, PIN_InterruptHandler); break; case IOR_PWM_n: case IOR_PWM_ScriptOnly: @@ -2032,6 +2072,9 @@ void PIN_ticks(void* param) int i; int value; + + PIN_ApplyCounterDeltas(); + #if defined(PLATFORM_BEKEN) || defined(WINDOWS) g_time = rtos_get_time(); #else diff --git a/src/new_pins.h b/src/new_pins.h index 5aaead8d0..ad8a154f1 100644 --- a/src/new_pins.h +++ b/src/new_pins.h @@ -574,6 +574,20 @@ typedef enum ioRole_e { //iodetail:"file":"new_pins.h", //iodetail:"driver":""} IOR_PWM_ScriptOnly_n, + //iodetail:{"name":"IOR_Counter_f", + //iodetail:"title":"TODO", + //iodetail:"descr":"", + //iodetail:"enum":"Counter_f", + //iodetail:"file":"new_pins.h", + //iodetail:"driver":""} + IOR_Counter_f, + //iodetail:{"name":"IOR_Counter_r", + //iodetail:"title":"TODO", + //iodetail:"descr":"", + //iodetail:"enum":"Counter_r", + //iodetail:"file":"new_pins.h", + //iodetail:"driver":""} + IOR_Counter_r, //iodetail:{"name":"Total_Options", //iodetail:"title":"TODO", //iodetail:"descr":"Current total number of available IOR roles",