text: /*
   *  Copyright (c) 2016, The OpenThread Authors.
   *  All rights reserved.
   *
   *  Redistribution and use in source and binary forms, with or without
   *  modification, are permitted provided that the following conditions are met:
   *  1. Redistributions of source code must retain the above copyright
   *     notice, this list of conditions and the following disclaimer.
   *  2. Redistributions in binary form must reproduce the above copyright
   *     notice, this list of conditions and the following disclaimer in the
   *     documentation and/or other materials provided with the distribution.
   *  3. Neither the name of the copyright holder nor the
   *     names of its contributors may be used to endorse or promote products
   *     derived from this software without specific prior written permission.
   *
   *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
   *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   *  POSSIBILITY OF SUCH DAMAGE.
   */
  
  #include <assert.h>
  #include <openthread-core-config.h>
  #include <openthread/config.h>
  
  #include <openthread/cli.h>
  #include <openthread/diag.h>
  #include <openthread/tasklet.h>
  #include <openthread/platform/logging.h>
  
  #include "openthread-system.h"
  #include <openthread/dataset_ftd.h>
  
  static void setNetworkConfiguration(otInstance *aInstance);
  
  
  // my test includes
  
  
  
  
  
  
  /* Headers for lower-level nRF52840 functions */
  
  
  
  #include <openthread/instance.h>
  #include <openthread/thread.h>
  #include <openthread/thread_ftd.h>
  
  
  #include <string.h>
  
  #include <openthread/message.h>
  #include <openthread/udp.h>
  
  #include "utils/code_utils.h"
  
  
  
  
  
  // end test includes
  
  #if OPENTHREAD_EXAMPLES_POSIX
  #include <setjmp.h>
  #include <unistd.h>
  
  jmp_buf gResetJump;
  
  void __gcov_flush();
  #endif
  
  #if OPENTHREAD_CONFIG_MULTIPLE_INSTANCE_ENABLE
  void *otPlatCAlloc(size_t aNum, size_t aSize)
  {
      return calloc(aNum, aSize);
  }
  
  void otPlatFree(void *aPtr)
  {
      free(aPtr);
  }
  #endif
  
  void otTaskletsSignalPending(otInstance *aInstance)
  {
      OT_UNUSED_VARIABLE(aInstance);
  }
  
  
  
  
  
  
  
  
  
  
  
  int main(int argc, char *argv[])
  {
      otInstance *instance;
  
  #if OPENTHREAD_EXAMPLES_POSIX
      if (setjmp(gResetJump))
      {
          alarm(0);
  #if OPENTHREAD_ENABLE_COVERAGE
          __gcov_flush();
  #endif
          execvp(argv[0], argv);
      }
  #endif
  
  #if OPENTHREAD_CONFIG_MULTIPLE_INSTANCE_ENABLE
      size_t   otInstanceBufferLength = 0;
      uint8_t *otInstanceBuffer       = NULL;
  #endif
  
  pseudo_reset:
  
      otSysInit(argc, argv);
  
  #if OPENTHREAD_CONFIG_MULTIPLE_INSTANCE_ENABLE
      // Call to query the buffer size
      (void)otInstanceInit(NULL, &otInstanceBufferLength);
  
      // Call to allocate the buffer
      otInstanceBuffer = (uint8_t *)malloc(otInstanceBufferLength);
      assert(otInstanceBuffer);
  
      // Initialize OpenThread with the buffer
      instance = otInstanceInit(otInstanceBuffer, &otInstanceBufferLength);
  #else
      instance = otInstanceInitSingle();
  #endif
      assert(instance);
  
      otCliUartInit(instance);
  
  
  /* Override default network credentials */
  setNetworkConfiguration(instance);
  
  /* Start the Thread network interface (CLI cmd > ifconfig up) */
  otIp6SetEnabled(instance, true);
  
  /* Start the Thread stack (CLI cmd > thread start) */
  otThreadSetEnabled(instance, true);
  
      while (!otSysPseudoResetWasRequested())
      {
          otTaskletsProcess(instance);
          otSysProcessDrivers(instance);
      }
  
      otInstanceFinalize(instance);
  #if OPENTHREAD_CONFIG_MULTIPLE_INSTANCE_ENABLE
      free(otInstanceBuffer);
  #endif
  
      goto pseudo_reset;
  
      return 0;
  }
  
  
  
  
  
  /**
   * Override default network settings, such as panid, so the devices can join a network
   */
  void setNetworkConfiguration(otInstance *aInstance)
  {
      static char          aNetworkName[] = "OTCodelab";
      otOperationalDataset aDataset;
  
      memset(&aDataset, 0, sizeof(otOperationalDataset));
  
      /*
       * Fields that can be configured in otOperationDataset to override defaults:
       *     Network Name, Mesh Local Prefix, Extended PAN ID, PAN ID, Delay Timer,
       *     Channel, Channel Mask Page 0, Network Master Key, PSKc, Security Policy
       */
      aDataset.mActiveTimestamp                      = 1;
      aDataset.mComponents.mIsActiveTimestampPresent = true;
  
      /* Set Channel to 15 */
      aDataset.mChannel                      = 15;
      aDataset.mComponents.mIsChannelPresent = true;
  
      /* Set Pan ID to 2222 */
      aDataset.mPanId                      = (otPanId)0x2222;
      aDataset.mComponents.mIsPanIdPresent = true;
  
      /* Set Extended Pan ID to C0DE1AB5C0DE1AB5 */
      uint8_t extPanId[OT_EXT_PAN_ID_SIZE] = {0xC0, 0xDE, 0x1A, 0xB5, 0xC0, 0xDE, 0x1A, 0xB5};
      memcpy(aDataset.mExtendedPanId.m8, extPanId, sizeof(aDataset.mExtendedPanId));
      aDataset.mComponents.mIsExtendedPanIdPresent = true;
  
      /* Set master key to 1234C0DE1AB51234C0DE1AB51234C0DE */
      uint8_t key[OT_MASTER_KEY_SIZE] = {0x12, 0x34, 0xC0, 0xDE, 0x1A, 0xB5, 0x12, 0x34, 0xC0, 0xDE, 0x1A, 0xB5};
      memcpy(aDataset.mMasterKey.m8, key, sizeof(aDataset.mMasterKey));
      aDataset.mComponents.mIsMasterKeyPresent = true;
  
      /* Set Network Name to OTCodelab */
      size_t length = strlen(aNetworkName);
      assert(length <= OT_NETWORK_NAME_MAX_SIZE);
      memcpy(aDataset.mNetworkName.m8, aNetworkName, length);
      aDataset.mComponents.mIsNetworkNamePresent = true;
  
      otDatasetSetActive(aInstance, &aDataset);
  
  }
  
  
  
  
  
  
  
  
  
  
  
  
  /*
   * Provide, if required an "otPlatLog()" function
   */
  #if OPENTHREAD_CONFIG_LOG_OUTPUT == OPENTHREAD_CONFIG_LOG_OUTPUT_APP
  void otPlatLog(otLogLevel aLogLevel, otLogRegion aLogRegion, const char *aFormat, ...)
  {
      OT_UNUSED_VARIABLE(aLogLevel);
      OT_UNUSED_VARIABLE(aLogRegion);
      OT_UNUSED_VARIABLE(aFormat);
  
      va_list ap;
      va_start(ap, aFormat);
      otCliPlatLogv(aLogLevel, aLogRegion, aFormat, ap);
      va_end(ap);
  }
  #endif
  