diff --git a/CMake/Modules/FindWindows.Devices.Gpio.cmake b/CMake/Modules/FindWindows.Devices.Gpio.cmake index b720ecff01..7cda082a85 100644 --- a/CMake/Modules/FindWindows.Devices.Gpio.cmake +++ b/CMake/Modules/FindWindows.Devices.Gpio.cmake @@ -22,6 +22,7 @@ set(Windows.Devices.Gpio_SRCS # class library source files win_dev_gpio_native_Windows_Devices_Gpio_GpioController.cpp win_dev_gpio_native_Windows_Devices_Gpio_GpioPin.cpp + win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter.cpp win_dev_gpio_native.cpp # core source files diff --git a/src/Windows.Devices.Gpio/win_dev_gpio_native.cpp b/src/Windows.Devices.Gpio/win_dev_gpio_native.cpp index 103a091336..3bd063a426 100644 --- a/src/Windows.Devices.Gpio/win_dev_gpio_native.cpp +++ b/src/Windows.Devices.Gpio/win_dev_gpio_native.cpp @@ -10,75 +10,93 @@ static const CLR_RT_MethodHandler method_lookup[] = { - NULL, - NULL, - NULL, - NULL, - Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioController::get_PinCount___I4, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioPin::Read___WindowsDevicesGpioGpioPinValue, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioPin::Toggle___VOID, - NULL, - Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioPin::DisposeNative___VOID, - Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioPin::NativeIsDriveModeSupported___BOOLEAN__WindowsDevicesGpioGpioPinDriveMode, - Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioPin::NativeSetDriveMode___VOID__WindowsDevicesGpioGpioPinDriveMode, - Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioPin::NativeInit___BOOLEAN__I4, - Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioPin::NativeSetDebounceTimeout___VOID, - Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioPin::WriteNative___VOID__WindowsDevicesGpioGpioPinValue, - Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioPin::NativeSetAlternateFunction___VOID__I4, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter::NativeInit___VOID, + Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter::NativeRead___U8__BOOLEAN, + Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter::NativeStart___VOID, + Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter::NativeStop___VOID, + Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter::NativeDispose___VOID, + NULL, + NULL, + NULL, + NULL, + Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioController::get_PinCount___I4, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioPin::Read___WindowsDevicesGpioGpioPinValue, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioPin::Toggle___VOID, + NULL, + Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioPin::DisposeNative___VOID, + Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioPin::NativeIsDriveModeSupported___BOOLEAN__WindowsDevicesGpioGpioPinDriveMode, + Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioPin::NativeSetDriveMode___VOID__WindowsDevicesGpioGpioPinDriveMode, + Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioPin::NativeInit___BOOLEAN__I4, + Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioPin::NativeSetDebounceTimeout___VOID, + Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioPin::WriteNative___VOID__WindowsDevicesGpioGpioPinValue, + Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioPin::NativeSetAlternateFunction___VOID__I4, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, }; const CLR_RT_NativeAssemblyData g_CLR_AssemblyNative_Windows_Devices_Gpio = { - "Windows.Devices.Gpio", - 0xF3FBAE36, - method_lookup, - { 100, 1, 0, 0 } + "Windows.Devices.Gpio", + 0xD7F65BB7, + method_lookup, + { 100, 1, 1, 0 } }; diff --git a/src/Windows.Devices.Gpio/win_dev_gpio_native.h b/src/Windows.Devices.Gpio/win_dev_gpio_native.h index d2d8f81172..8422022790 100644 --- a/src/Windows.Devices.Gpio/win_dev_gpio_native.h +++ b/src/Windows.Devices.Gpio/win_dev_gpio_native.h @@ -39,8 +39,51 @@ enum GpioPinValue }; /////////////////////////////////////////////////////////////////////////////////// +// !!! KEEP IN SYNC WITH Windows.Devices.Gpio.GpioChangePolarity (in managed code) !!! // /////////////////////////////////////////////////////////////////////////////////// +enum GpioChangePolarity +{ + Both = 0, + Falling, + Rising +}; + + +/////////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////////// + +struct Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCount +{ + static const int FIELD__Count = 1; + static const int FIELD__RelativeTime = 2; + + + //--// + +}; + +struct Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter +{ + static const int FIELD___pinNumber = 1; + static const int FIELD___inputMode = 2; + static const int FIELD___polarity = 3; + static const int FIELD___CountActive = 4; + static const int FIELD___readTime = 5; + static const int FIELD___syncLock = 6; + static const int FIELD___disposedValue = 7; + + NANOCLR_NATIVE_DECLARE(NativeInit___VOID); + NANOCLR_NATIVE_DECLARE(NativeRead___U8__BOOLEAN); + NANOCLR_NATIVE_DECLARE(NativeStart___VOID); + NANOCLR_NATIVE_DECLARE(NativeStop___VOID); + NANOCLR_NATIVE_DECLARE(NativeDispose___VOID); + + //--// + +}; + + struct Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioController { static const int FIELD_STATIC___syncLock = 0; diff --git a/targets/CMSIS-OS/ChibiOS/nanoCLR/Windows.Devices.Gpio/win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter.cpp b/targets/CMSIS-OS/ChibiOS/nanoCLR/Windows.Devices.Gpio/win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter.cpp new file mode 100644 index 0000000000..d6c6623a48 --- /dev/null +++ b/targets/CMSIS-OS/ChibiOS/nanoCLR/Windows.Devices.Gpio/win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter.cpp @@ -0,0 +1,86 @@ +// +// Copyright (c) 2019 The nanoFramework project contributors +// Portions Copyright (c) Microsoft Corporation. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#include "win_dev_gpio_native.h" + +HRESULT Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter::NativeInit___VOID( CLR_RT_StackFrame& stack ) +{ + (void)stack; + + NANOCLR_HEADER(); + { + //CLR_RT_HeapBlock* pThis = stack.This(); FAULT_ON_NULL(pThis); + + //int16_t pinNumber = pThis[ FIELD___pinNumber ].NumericByRefConst().s4; + //bool InputMode = (bool)pThis[FIELD___inputMode].NumericByRefConst().u1; + + NANOCLR_SET_AND_LEAVE(CLR_E_NOT_SUPPORTED); + } + NANOCLR_NOCLEANUP(); +} + +HRESULT Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter::NativeRead___U8__BOOLEAN( CLR_RT_StackFrame& stack ) +{ + (void)stack; + + NANOCLR_HEADER(); + { + NANOCLR_SET_AND_LEAVE(CLR_E_NOT_SUPPORTED); + + } + NANOCLR_NOCLEANUP(); +} + +HRESULT Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter::NativeStart___VOID( CLR_RT_StackFrame& stack ) +{ + (void)stack; + + NANOCLR_HEADER(); + { + //CLR_RT_HeapBlock* pThis = stack.This(); FAULT_ON_NULL(pThis); + + //int pinNumber = pThis[ FIELD___pinNumber ].NumericByRefConst().s4; + + //GpioChangePolarity polarity = (GpioChangePolarity)pThis[ FIELD___Polarity ].NumericByRefConst().s4; + + + // TODO + NANOCLR_SET_AND_LEAVE(CLR_E_NOT_SUPPORTED); + + + } + NANOCLR_NOCLEANUP(); +} + +HRESULT Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter::NativeStop___VOID( CLR_RT_StackFrame& stack ) +{ + (void)stack; + + NANOCLR_HEADER(); + { + //CLR_RT_HeapBlock* pThis = stack.This(); FAULT_ON_NULL(pThis); + + //int pinNumber = pThis[ FIELD___pinNumber ].NumericByRefConst().s4; + NANOCLR_SET_AND_LEAVE(CLR_E_NOT_SUPPORTED); + + } + NANOCLR_NOCLEANUP(); +} + +HRESULT Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter::NativeDispose___VOID( CLR_RT_StackFrame& stack ) +{ + (void)stack; + + NANOCLR_HEADER(); + { + //CLR_RT_HeapBlock* pThis = stack.This(); FAULT_ON_NULL(pThis); + + //int pinNumber = pThis[ FIELD___pinNumber ].NumericByRefConst().s4; + NANOCLR_SET_AND_LEAVE(CLR_E_NOT_SUPPORTED); + + } + NANOCLR_NOCLEANUP(); +} diff --git a/targets/FreeRTOS_ESP32/ESP32_WROOM_32/Include/esp32_os.h b/targets/FreeRTOS_ESP32/ESP32_WROOM_32/Include/esp32_os.h index 33491bbd2c..bd80788021 100644 --- a/targets/FreeRTOS_ESP32/ESP32_WROOM_32/Include/esp32_os.h +++ b/targets/FreeRTOS_ESP32/ESP32_WROOM_32/Include/esp32_os.h @@ -31,6 +31,7 @@ #include "dac.h" #include "timer.h" #include "esp_spiffs.h" +#include "pcnt.h" // Uncomment to support Ethernet //#define ESP32_ETHERNET_SUPPORT 1 diff --git a/targets/FreeRTOS_ESP32/ESP32_WROOM_32/nanoCLR/Windows.Devices.Gpio/win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter.cpp b/targets/FreeRTOS_ESP32/ESP32_WROOM_32/nanoCLR/Windows.Devices.Gpio/win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter.cpp new file mode 100644 index 0000000000..3bdc6d4b5f --- /dev/null +++ b/targets/FreeRTOS_ESP32/ESP32_WROOM_32/nanoCLR/Windows.Devices.Gpio/win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter.cpp @@ -0,0 +1,303 @@ +// +// Copyright (c) 2019 The nanoFramework project contributors +// Portions Copyright (c) Microsoft Corporation. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#include "win_dev_gpio_native.h" + +// Map Gpio pin number to 1 of 8 ESP32 counters, -1 = not mapped +// Each pulse counter is a 16 bit signed value. +// The managed code requires a 64 bit counter so we accumulate the overflows in an interrupt when count gets to 0x7fff + +static int8_t IsrInstalled = 0; +static int8_t GpioCounterMap[8] = { -1,-1,-1,-1,-1,-1,-1,-1 }; +static uint64_t OverflowCount[8]; + +#define MAX_COUNTER_VALUE 0x7fff + +extern void Remove_Gpio_Interrupt(gpio_num_t pinNumber); + + +// Interrupt routine used to catch overflows so we can have a 64 bit counter +static void IRAM_ATTR pcnt_intr_handler(void *arg) +{ + (void)arg; + + uint32_t intr_status = PCNT.int_st.val; + + for (int i = 0; i < PCNT_UNIT_MAX; i++) + { + if (intr_status & (BIT(i))) + { + + uint32_t status = PCNT.status_unit[i].val; + // Hit high limit MAX_COUNTER_VALUE + if (status & PCNT_STATUS_H_LIM_M) + { + OverflowCount[i] += MAX_COUNTER_VALUE; + } + + PCNT.int_clr.val = BIT(i); + } + } +} + + +// Find an unused counter, returns counter index or -1 if not found +static int FindFreeCounter(int gpioPin) +{ + int counterIndex; + + for (counterIndex = 0; counterIndex < 8; counterIndex++) + { + if (GpioCounterMap[counterIndex] == -1) + { + GpioCounterMap[counterIndex] = gpioPin; + return counterIndex; + } + } + return -1; +} + +// Find the index of counter for a gpio pin, returns index or -1 if not found +static int FindCounterForGpio(int gpioPin) +{ + int counterIndex; + + for (counterIndex = 0; counterIndex < 8; counterIndex++) + { + if (GpioCounterMap[counterIndex] == gpioPin) return counterIndex; + } + return -1; +} + +// Initalise the ESP32 counter +// return true if ok +static bool InitialiseCounter(int counterIndex, int gpioNum, bool countRising, bool countFalling) +{ + esp_err_t ec; + + // Prepare configuration for the PCNT unit */ + pcnt_config_t pcnt_config; + + // Set PCNT input signal and control GPIOs + pcnt_config.pulse_gpio_num = gpioNum; + pcnt_config.ctrl_gpio_num = PCNT_PIN_NOT_USED; // ignore + + pcnt_config.channel = PCNT_CHANNEL_0; + pcnt_config.unit = (pcnt_unit_t)counterIndex; + + // What to do on the positive / negative edge of pulse input? + pcnt_config.pos_mode = countRising ? PCNT_COUNT_INC : PCNT_COUNT_DIS; // positive edge count ? + pcnt_config.neg_mode = countFalling ? PCNT_COUNT_INC : PCNT_COUNT_DIS; // falling edge count ? + + // What to do when control input is low or high? + pcnt_config.lctrl_mode = PCNT_MODE_KEEP; // Keep the primary counter mode if low + pcnt_config.hctrl_mode = PCNT_MODE_KEEP; // Keep the primary counter mode if high + + // Set the maximum and minimum limit values to watch + pcnt_config.counter_h_lim = MAX_COUNTER_VALUE; + pcnt_config.counter_l_lim = 0; + + //* Initialize PCNT unit + ec = pcnt_unit_config(&pcnt_config); + if (ec != ESP_OK) return false; + + return true; +} + +HRESULT Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter::NativeInit___VOID(CLR_RT_StackFrame& stack) +{ + NANOCLR_HEADER(); + { + CLR_RT_HeapBlock* pThis = stack.This(); FAULT_ON_NULL(pThis); + + int16_t pinNumber = pThis[FIELD___pinNumber].NumericByRefConst().s4; + + bool InputMode = (bool)pThis[FIELD___inputMode].NumericByRefConst().u1; + if (InputMode) + { + int index = FindFreeCounter(pinNumber); + if (index == -1) + { + // No free counters + NANOCLR_SET_AND_LEAVE(CLR_E_NOT_SUPPORTED); + } + + // Make sure GPIO pin doesn't have a GPIO Isr asscoiatted with it otherwise it will not support + // faster count frequencies + Remove_Gpio_Interrupt((gpio_num_t)pinNumber); + } + else + { + // Output not currently supported + NANOCLR_SET_AND_LEAVE(CLR_E_NOT_SUPPORTED); + } + + } + NANOCLR_NOCLEANUP(); +} + +HRESULT Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter::NativeRead___U8__BOOLEAN(CLR_RT_StackFrame& stack) +{ + NANOCLR_HEADER(); + { + CLR_RT_HeapBlock* pThis = stack.This(); FAULT_ON_NULL(pThis); + + // check if object has been disposed + if (pThis[Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter::FIELD___disposedValue].NumericByRef().u1 != 0) + { + NANOCLR_SET_AND_LEAVE(CLR_E_OBJECT_DISPOSED); + } + + int pinNumber = pThis[FIELD___pinNumber].NumericByRefConst().s4; + + int counterIndex = FindCounterForGpio(pinNumber); + if (counterIndex == -1) + { + NANOCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER); + } + + bool resetAfterRead = (bool)stack.Arg0().NumericByRef().u1; + + int16_t counter; + + pcnt_get_counter_value((pcnt_unit_t)counterIndex, &counter); + + // relativeTime Read Time, Number of micro seconds since boot + int64_t relativeTime = esp_timer_get_time(); + + // Combine to make a 64 bit value + uint64_t totalCount = OverflowCount[counterIndex] + (uint64_t)counter; + + if (resetAfterRead) + { + pcnt_counter_clear((pcnt_unit_t)counterIndex); + OverflowCount[counterIndex] = 0; + } + + + // Return results + // Update the Relative _readTime field (convert micro sec to 100ns ticks) + *&pThis[FIELD___readTime].NumericByRef().s8 = (relativeTime * 10); + + // Return value to the managed application + stack.SetResult_U8(totalCount); + + } + NANOCLR_NOCLEANUP(); +} + +HRESULT Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter::NativeStart___VOID(CLR_RT_StackFrame& stack) +{ + NANOCLR_HEADER(); + { + bool countRising = false; + bool countFalling = false; + + CLR_RT_HeapBlock* pThis = stack.This(); FAULT_ON_NULL(pThis); + + // check if object has been disposed + if (pThis[Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter::FIELD___disposedValue].NumericByRef().u1 != 0) + { + NANOCLR_SET_AND_LEAVE(CLR_E_OBJECT_DISPOSED); + } + + int pinNumber = pThis[FIELD___pinNumber].NumericByRefConst().s4; + + int counterIndex = FindCounterForGpio(pinNumber); + if (counterIndex == -1) + { + NANOCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER); + } + + GpioChangePolarity polarity = (GpioChangePolarity)pThis[FIELD___polarity].NumericByRefConst().s4; + + switch (polarity) + { + case Both: countRising = true; countFalling = true; break; + case Rising: countRising = true; break; + case Falling: countFalling = true; break; + } + + if (!InitialiseCounter(counterIndex, pinNumber, countRising, countFalling)) + { + NANOCLR_SET_AND_LEAVE(CLR_E_NOT_SUPPORTED); + } + + // Posible filter ( debounce ) future. + // pcnt_set_filter_value((pcnt_unit_t)counterIndex, 10); + // pcnt_filter_enable((pcnt_unit_t)counterIndex); + + pcnt_event_enable((pcnt_unit_t)counterIndex, PCNT_EVT_H_LIM); + + pcnt_counter_pause((pcnt_unit_t)counterIndex); + + pcnt_counter_clear((pcnt_unit_t)counterIndex); + OverflowCount[counterIndex] = 0; + + // Register ISR handler and enable interrupts for PCNT unit */ + if (IsrInstalled == 0) + { + pcnt_isr_register(pcnt_intr_handler, NULL, 0, NULL); + IsrInstalled = 1; + } + + // enable interrupts for PCNT unit + pcnt_intr_enable((pcnt_unit_t)counterIndex); + + pcnt_counter_resume((pcnt_unit_t)counterIndex); + } + NANOCLR_NOCLEANUP(); +} + +HRESULT Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter::NativeStop___VOID(CLR_RT_StackFrame& stack) +{ + NANOCLR_HEADER(); + { + CLR_RT_HeapBlock* pThis = stack.This(); FAULT_ON_NULL(pThis); + + // check if object has been disposed + if (pThis[Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter::FIELD___disposedValue].NumericByRef().u1 != 0) + { + NANOCLR_SET_AND_LEAVE(CLR_E_OBJECT_DISPOSED); + } + + int pinNumber = pThis[FIELD___pinNumber].NumericByRefConst().s4; + + int counterIndex = FindCounterForGpio(pinNumber); + if (counterIndex == -1) + { + NANOCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER); + } + + pcnt_counter_pause((pcnt_unit_t)counterIndex); + } + NANOCLR_NOCLEANUP(); +} + +HRESULT Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter::NativeDispose___VOID(CLR_RT_StackFrame& stack) +{ + NANOCLR_HEADER(); + { + CLR_RT_HeapBlock* pThis = stack.This(); FAULT_ON_NULL(pThis); + + int pinNumber = pThis[FIELD___pinNumber].NumericByRefConst().s4; + + int counterIndex = FindCounterForGpio(pinNumber); + if (counterIndex == -1) + { + NANOCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER); + } + + pcnt_intr_disable((pcnt_unit_t)counterIndex); + + // Disable counter, remove gpio pin + InitialiseCounter(counterIndex, PCNT_PIN_NOT_USED, false, false); + + // Clear counter / gpio mapping + GpioCounterMap[counterIndex] = -1; + } + NANOCLR_NOCLEANUP(); +} diff --git a/targets/FreeRTOS_ESP32/ESP32_WROOM_32/nanoCLR/Windows.Devices.Gpio/win_dev_gpio_native_Windows_Devices_Gpio_GpioPin.cpp b/targets/FreeRTOS_ESP32/ESP32_WROOM_32/nanoCLR/Windows.Devices.Gpio/win_dev_gpio_native_Windows_Devices_Gpio_GpioPin.cpp index 8e61d73de7..7aafaade0c 100644 --- a/targets/FreeRTOS_ESP32/ESP32_WROOM_32/nanoCLR/Windows.Devices.Gpio/win_dev_gpio_native_Windows_Devices_Gpio_GpioPin.cpp +++ b/targets/FreeRTOS_ESP32/ESP32_WROOM_32/nanoCLR/Windows.Devices.Gpio/win_dev_gpio_native_Windows_Devices_Gpio_GpioPin.cpp @@ -83,6 +83,18 @@ void Add_Gpio_Interrupt(gpio_num_t pinNumber) } +void Remove_Gpio_Interrupt(gpio_num_t pinNumber) +{ + if (channelPinMapping[pinNumber] != NULL) + { + // Remove from interrupts + gpio_isr_handler_remove((gpio_num_t)pinNumber); + + // clear this channel in channel pin mapping + channelPinMapping[pinNumber] = NULL; + } +} + HRESULT Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioPin::Read___WindowsDevicesGpioGpioPinValue( CLR_RT_StackFrame& stack ) { NANOCLR_HEADER(); @@ -147,15 +159,7 @@ HRESULT Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioPin::DisposeNative_ // releases the pin int16_t pinNumber = pThis[ FIELD___pinNumber ].NumericByRefConst().s4; - - if ( channelPinMapping[pinNumber] != NULL ) - { - // Remove from interrupts - gpio_isr_handler_remove((gpio_num_t)pinNumber); - - // clear this channel in channel pin mapping - channelPinMapping[pinNumber] = NULL; - } + Remove_Gpio_Interrupt((gpio_num_t)pinNumber); } NANOCLR_NOCLEANUP(); } diff --git a/targets/TI-SimpleLink/nanoCLR/Windows.Devices.Gpio/win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter.cpp b/targets/TI-SimpleLink/nanoCLR/Windows.Devices.Gpio/win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter.cpp new file mode 100644 index 0000000000..87c7fcd47b --- /dev/null +++ b/targets/TI-SimpleLink/nanoCLR/Windows.Devices.Gpio/win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter.cpp @@ -0,0 +1,86 @@ +// +// Copyright (c) 2019 The nanoFramework project contributors +// Portions Copyright (c) Microsoft Corporation. All rights reserved. +// See LICENSE file in the project root for full license information. +// + +#include "win_dev_gpio_native.h" + +HRESULT Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter::NativeInit___VOID(CLR_RT_StackFrame& stack) +{ + (void)stack; + + NANOCLR_HEADER(); + { + //CLR_RT_HeapBlock* pThis = stack.This(); FAULT_ON_NULL(pThis); + + //int16_t pinNumber = pThis[ FIELD___pinNumber ].NumericByRefConst().s4; + //bool InputMode = (bool)pThis[FIELD___inputMode].NumericByRefConst().u1; + + NANOCLR_SET_AND_LEAVE(CLR_E_NOT_SUPPORTED); + } + NANOCLR_NOCLEANUP(); +} + +HRESULT Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter::NativeRead___U8__BOOLEAN(CLR_RT_StackFrame& stack) +{ + (void)stack; + + NANOCLR_HEADER(); + { + NANOCLR_SET_AND_LEAVE(CLR_E_NOT_SUPPORTED); + + } + NANOCLR_NOCLEANUP(); +} + +HRESULT Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter::NativeStart___VOID(CLR_RT_StackFrame& stack) +{ + (void)stack; + + NANOCLR_HEADER(); + { + //CLR_RT_HeapBlock* pThis = stack.This(); FAULT_ON_NULL(pThis); + + //int pinNumber = pThis[ FIELD___pinNumber ].NumericByRefConst().s4; + + //GpioChangePolarity polarity = (GpioChangePolarity)pThis[ FIELD___Polarity ].NumericByRefConst().s4; + + + // TODO + NANOCLR_SET_AND_LEAVE(CLR_E_NOT_SUPPORTED); + + + } + NANOCLR_NOCLEANUP(); +} + +HRESULT Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter::NativeStop___VOID(CLR_RT_StackFrame& stack) +{ + (void)stack; + + NANOCLR_HEADER(); + { + //CLR_RT_HeapBlock* pThis = stack.This(); FAULT_ON_NULL(pThis); + + //int pinNumber = pThis[ FIELD___pinNumber ].NumericByRefConst().s4; + NANOCLR_SET_AND_LEAVE(CLR_E_NOT_SUPPORTED); + + } + NANOCLR_NOCLEANUP(); +} + +HRESULT Library_win_dev_gpio_native_Windows_Devices_Gpio_GpioChangeCounter::NativeDispose___VOID(CLR_RT_StackFrame& stack) +{ + (void)stack; + + NANOCLR_HEADER(); + { + //CLR_RT_HeapBlock* pThis = stack.This(); FAULT_ON_NULL(pThis); + + //int pinNumber = pThis[ FIELD___pinNumber ].NumericByRefConst().s4; + NANOCLR_SET_AND_LEAVE(CLR_E_NOT_SUPPORTED); + + } + NANOCLR_NOCLEANUP(); +}