Merge pull request #597 from erjiaqing/esp32-ot

Add OpenThread Support to ESP32 DeviceLayer using ot-esp32

Author: robszewczyk

build/esp32/components/openweave/Kconfig

@@ -393,7 +393,14 @@ menu "OpenWeave Device Layer"
                 The priority of the Weave task.
 
                 On the ESP32 platform this value is added to ESP_TASK_PRIO_MIN to determine the FreeRTOS priority value.
-        
+
+        config THREAD_TASK_STACK_SIZE
+            int "Thread Task Stack Size"
+            range 0 65535
+            default 8192
+            help
+                The size (in bytes) of the Thread task stack.
+
         config MAX_EVENT_QUEUE_SIZE
             int "Max Event Queue Size"
             range 0 65535
@@ -657,6 +664,14 @@ menu "OpenWeave Device Layer"
 
     endmenu
 
+    menu "Thread Options"
+
+        config WEAVE_DEVICE_CONFIG_ENABLE_THREAD
+            bool "Enable Thread support (with external RCP)"
+            default n
+
+    endmenu
+    
     menu "Service Provisioning Options"
 
         config SERVICE_PROVISIONING_ENDPOINT_ID

src/adaptations/device-layer/ESP32/ConfigurationManagerImpl.cpp

@@ -239,6 +239,12 @@ void ConfigurationManagerImpl::DoFactoryReset(intptr_t arg)
         WeaveLogError(DeviceLayer, "esp_wifi_restore() failed: %s", nl::ErrorStr(err));
     }
 
+#if WEAVE_DEVICE_CONFIG_ENABLE_THREAD
+    ThreadStackMgrImpl().LockThreadStack();
+    otInstanceFactoryReset(ThreadStackMgrImpl().OTInstance());
+    ThreadStackMgrImpl().UnlockThreadStack();
+#endif
+
     // Restart the system.
     WeaveLogProgress(DeviceLayer, "System restarting");
     esp_restart();

src/adaptations/device-layer/ESP32/ConnectivityManagerImpl.cpp

@@ -57,6 +57,10 @@
 #include <nest/trait/network/TelemetryNetworkWifiTrait.h>
 #endif
 
+#if WEAVE_DEVICE_CONFIG_ENABLE_THREAD
+#include <Weave/DeviceLayer/internal/GenericConnectivityManagerImpl_Thread.ipp>
+#endif
+
 using namespace ::nl;
 using namespace ::nl::Weave;
 using namespace ::nl::Weave::TLV;
@@ -398,6 +402,10 @@ WEAVE_ERROR ConnectivityManagerImpl::_Init()
     mWiFiAPIdleTimeoutMS = WEAVE_DEVICE_CONFIG_WIFI_AP_IDLE_TIMEOUT;
     mFlags = 0;
 
+#if WEAVE_DEVICE_CONFIG_ENABLE_THREAD
+    GenericConnectivityManagerImpl_Thread<ConnectivityManagerImpl>::_Init();
+#endif 
+
     // Initialize the Weave Addressing and Routing Module.
     err = Warm::Init(FabricState);
     SuccessOrExit(err);
@@ -555,6 +563,10 @@ void ConnectivityManagerImpl::_OnPlatformEvent(const WeaveDeviceEvent * event)
     }
 
 #endif // !WEAVE_DEVICE_CONFIG_DISABLE_ACCOUNT_PAIRING
+
+#if WEAVE_DEVICE_CONFIG_ENABLE_THREAD
+    GenericConnectivityManagerImpl_Thread<ConnectivityManagerImpl>::_OnPlatformEvent(event);
+#endif // WEAVE_DEVICE_CONFIG_ENABLE_THREAD
 }
 
 void ConnectivityManagerImpl::_OnWiFiScanDone()

src/adaptations/device-layer/ESP32/ThreadStackManagerImpl.cpp

@@ -0,0 +1,146 @@
+/*
+ *
+ *    Copyright (c) 2019 Nest Labs, Inc.
+ *    All rights reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+/**
+ *    @file     
+ *          Provides an implementation of the ThreadStackManager object for
+ *          ESP32 platforms using the ESP-IDF SDK and the OpenThread
+ *          stack.
+ *
+ */
+
+#include <Weave/DeviceLayer/internal/WeaveDeviceLayerInternal.h>
+
+#if WEAVE_DEVICE_CONFIG_ENABLE_THREAD
+
+#include <Weave/DeviceLayer/ThreadStackManager.h>
+#include <Weave/DeviceLayer/OpenThread/OpenThreadUtils.h>
+
+#include <Weave/DeviceLayer/FreeRTOS/GenericThreadStackManagerImpl_FreeRTOS.ipp>
+#include <Weave/DeviceLayer/OpenThread/GenericThreadStackManagerImpl_OpenThread_LwIP.ipp>
+
+#include <openthread/cli.h>
+
+#include <openthread/openthread-esp32.h>
+
+namespace nl {
+namespace Weave {
+namespace DeviceLayer {
+
+using namespace ::nl::Weave::DeviceLayer::Internal;
+
+namespace Internal {
+
+// Specialize ESP32 ThreadStackManagerImpl's ThreadTaskMain since OpenThread on ESP32 is using a RCP for thread support.
+template<>
+void GenericThreadStackManagerImpl_FreeRTOS<ThreadStackManagerImpl>::ThreadTaskMain(void * arg)
+{
+    GenericThreadStackManagerImpl_FreeRTOS<ThreadStackManagerImpl> * self =
+            static_cast<GenericThreadStackManagerImpl_FreeRTOS<ThreadStackManagerImpl>*>(arg);
+
+    VerifyOrDie(self->mThreadTask == NULL);
+
+    WeaveLogDetail(DeviceLayer, "Thread task running");
+
+    // Capture the Thread task handle.
+    self->mThreadTask = xTaskGetCurrentTaskHandle();
+
+    ThreadStackMgr().LockThreadStack();
+    otInstance *instance = ThreadStackMgrImpl().OTInstance();
+    ThreadStackMgr().UnlockThreadStack();
+    
+
+    while (true)
+    {
+        otSysMainloopContext mainloop;
+ 
+        otSysMainloopInit(&mainloop);
+
+        ThreadStackMgr().LockThreadStack();
+        otTaskletsProcess(instance);
+        otSysMainloopUpdate(instance, &mainloop);
+        ThreadStackMgr().UnlockThreadStack();
+ 
+        if (otSysMainloopPoll(&mainloop) >= 0)
+        {
+            ThreadStackMgr().LockThreadStack();
+            otSysMainloopProcess(instance, &mainloop);
+            ThreadStackMgr().UnlockThreadStack();
+        }
+        else
+        {
+            WeaveLogError(DeviceLayer, "OpenThread system polling failed");
+            abort();
+        }
+    }
+}
+
+}
+
+ThreadStackManagerImpl ThreadStackManagerImpl::sInstance;
+
+WEAVE_ERROR ThreadStackManagerImpl::_InitThreadStack(void)
+{
+    return InitThreadStack(NULL);
+}
+
+WEAVE_ERROR ThreadStackManagerImpl::InitThreadStack(otInstance *otInst)
+{
+    WEAVE_ERROR err = WEAVE_NO_ERROR;
+
+    // Initialize the generic implementation base classes.
+    err = GenericThreadStackManagerImpl_FreeRTOS<ThreadStackManagerImpl>::DoInit();
+    SuccessOrExit(err);
+    err = GenericThreadStackManagerImpl_OpenThread_LwIP<ThreadStackManagerImpl>::DoInit(otInst);
+    SuccessOrExit(err);
+
+exit:
+    return err;
+}
+
+bool ThreadStackManagerImpl::IsInitialized()
+{
+    return sInstance.mThreadStackLock != NULL;
+}
+
+} // namespace DeviceLayer
+} // namespace Weave
+} // namespace nl
+
+using namespace ::nl::Weave::DeviceLayer;
+
+/**
+ * Glue function called directly by the OpenThread stack when tasklet processing work
+ * is pending.
+ */
+extern "C" void otTaskletsSignalPending(otInstance *p_instance)
+{
+    ThreadStackMgrImpl().SignalThreadActivityPending();
+}
+
+/**
+ * Glue function called directly by the OpenThread stack when system event processing work
+ * is pending.
+ */
+extern "C" void otSysEventSignalPending(void)
+{
+    BaseType_t yieldRequired = ThreadStackMgrImpl().SignalThreadActivityPendingFromISR();
+    if (yieldRequired) portYIELD_FROM_ISR();
+}
+
+#endif // WEAVE_DEVICE_CONFIG_ENABLE_THREAD

src/adaptations/device-layer/LwIP/WarmSupport.cpp

@@ -448,8 +448,6 @@ PlatformResult AddRemoveThreadRoute(InterfaceType inInterfaceType, const Inet::I
 
     ThreadStackMgrImpl().LockThreadStack();
 
-    otBorderRouterRegister(ThreadStackMgrImpl().OTInstance());
-
     memcpy(routeConfig.mPrefix.mPrefix.mFields.m8, inPrefix.IPAddr.Addr, sizeof(routeConfig.mPrefix.mPrefix.mFields));
     routeConfig.mPrefix.mLength = inPrefix.Length;
     routeConfig.mStable = true;
@@ -464,6 +462,8 @@ PlatformResult AddRemoveThreadRoute(InterfaceType inInterfaceType, const Inet::I
         otErr = otBorderRouterRemoveRoute(ThreadStackMgrImpl().OTInstance(), &routeConfig.mPrefix);
     }
 
+    otBorderRouterRegister(ThreadStackMgrImpl().OTInstance());
+
     ThreadStackMgrImpl().UnlockThreadStack();
 
     if (otErr == OT_ERROR_NONE)

src/adaptations/device-layer/Makefile.am

@@ -47,6 +47,7 @@ noinst_HEADERS                          = \
     include/Weave/DeviceLayer/ESP32/SoftwareUpdateManagerImpl.h \
     include/Weave/DeviceLayer/ESP32/WeaveDevicePlatformEvent.h \
     include/Weave/DeviceLayer/ESP32/NetworkProvisioningServerImpl.h \
+    include/Weave/DeviceLayer/ESP32/ThreadStackManagerImpl.h \
     include/Weave/DeviceLayer/nRF5/ConfigurationManagerImpl.h \
     include/Weave/DeviceLayer/nRF5/PlatformManagerImpl.h \
     include/Weave/DeviceLayer/nRF5/nRF5Config.h \
@@ -169,6 +170,8 @@ libDeviceLayer_a_SOURCES               +=       \
     ESP32/PlatformManagerImpl.cpp               \
     ESP32/SoftwareUpdateManagerImpl.cpp         \
     ESP32/SystemTimeSupport.cpp                 \
+    ESP32/ThreadStackManagerImpl.cpp            \ 
+    OpenThread/OpenThreadUtils.cpp              \
     LwIP/WarmSupport.cpp                        \
     $(NULL)
 

src/adaptations/device-layer/OpenThread/OpenThreadUtils.cpp

@@ -23,6 +23,9 @@
 
 
 #include <Weave/DeviceLayer/internal/WeaveDeviceLayerInternal.h>
+
+#if WEAVE_DEVICE_CONFIG_ENABLE_THREAD
+
 #include <Weave/DeviceLayer/OpenThread/OpenThreadUtils.h>
 
 #include <openthread/error.h>
@@ -276,3 +279,5 @@ const char * OpenThreadRoleToStr(otDeviceRole role)
 } // namespace DeviceLayer
 } // namespace Weave
 } // namespace nl
+
+#endif // WEAVE_DEVICE_CONFIG_ENABLE_THREAD

src/adaptations/device-layer/include/Weave/DeviceLayer/ESP32/ConnectivityManagerImpl.h

@@ -26,6 +26,11 @@
 #else
 #include <Weave/DeviceLayer/internal/GenericConnectivityManagerImpl_NoBLE.h>
 #endif
+#if WEAVE_DEVICE_CONFIG_ENABLE_THREAD
+#include <Weave/DeviceLayer/internal/GenericConnectivityManagerImpl_Thread.h>
+#else
+#include <Weave/DeviceLayer/internal/GenericConnectivityManagerImpl_NoThread.h>
+#endif
 #include <Weave/DeviceLayer/internal/GenericConnectivityManagerImpl_NoThread.h>
 #include <Weave/Profiles/network-provisioning/NetworkProvisioning.h>
 #include <Weave/Profiles/weave-tunneling/WeaveTunnelCommon.h>
@@ -64,7 +69,11 @@ class ConnectivityManagerImpl final
 #else
       public Internal::GenericConnectivityManagerImpl_NoBLE<ConnectivityManagerImpl>,
 #endif
+#if WEAVE_DEVICE_CONFIG_ENABLE_THREAD
+      public Internal::GenericConnectivityManagerImpl_Thread<ConnectivityManagerImpl>
+#else
       public Internal::GenericConnectivityManagerImpl_NoThread<ConnectivityManagerImpl>
+#endif
 {
     using TunnelConnNotifyReasons = ::nl::Weave::Profiles::WeaveTunnel::WeaveTunnelConnectionMgr::TunnelConnNotifyReasons;