WMBus StackForce serial T2 collector stack receiving encrypted SND-NR frames

/**
 * @code
 *  ___ _____ _   ___ _  _____ ___  ___  ___ ___
 * / __|_   _/_\ / __| |/ / __/ _ \| _ \/ __| __|
 * \__ \ | |/ _ \ (__| ' <| _| (_) |   / (__| _|
 * |___/ |_/_/ \_\___|_|\_\_| \___/|_|_\\___|___|
 * embedded.connectivity.solutions.==============
 * @endcode
 *
 * @file
 * @copyright  STACKFORCE GmbH, Heitersheim, Germany, www.stackforce.de
 * @author     Naksit Anantalapochai <naksit.anantalapochai@stackforce.de>
 * @author     Alexander Rohleder <alexander.rohleder@stackforce.de>
 * @author     Mario Behringer <mario.behringer@stackforce.de>
 *
 * @example    main_collector.c
 *
 *             # Collector Demo Application
 *
 *             The main task of this application is to demonstrate how to setup a
 *             static meterlist, how the collector device can receive WMBUS
 *             telegrams and how to start a bidirectional communication
 *             with a meter device.\n
 *             \n
 *             The collector device installs a (preconfigured) WMBUS meter device
 *             into the meterlist with the start attributes of the device. After
 *             initialization, the collector is ready to receive WMBUS telegrams
 *             from the meter devices which are in its meterlist.
 *             After the collector has received a specified number
 *             (@ref NUMBER_OF_TELEGRAMS_BEFORE_SND_UD, default is 5) of telegrams from the
 *             WMBUS meter device, it initiates a bidirectional communication.\n
 *             \n
 *             The following diagram shows the communication sequence when running
 *             this collector demo application with the compatible meter.
 *
 *             <b><pre>
 *             +-------+                                    +-----------+
 *             | Meter |                                    | Collector |
 *             +-------+                                    +-----------+
 *                 |                   SND-NR                     |
 *                 |--------------------------------------------->|--+
 *                 |                                              |  | rxSndNrCounter++
 *                 |                                              |<-+
 *                 |                   SND-NR                     |
 *                 |--------------------------------------------->|--+
 *                 |                                              |  | rxSndNrCounter++
 *                 |                                              |<-+
 *                 |    |          rxSndNrCounter == 5       |    |
 *                 |    | Starts Bidirectional Communication |    |
 *                 |                                              |
 *                 |                   SND-UD                     |
 *                 |<---------------------------------------------|
 *                 |                    ACK                       |
 *                 |--------------------------------------------->|
 *                 |                   SND-NKE                    |
 *                 |<---------------------------------------------|--+
 *                 |                                              |  | rxSndNrCounter = 0 (reset)
 *                 |                                              |<-+
 *                 |                   SND-NR                     |
 *                 |--------------------------------------------->|
 *                 |                                              |
 *                 |        | Until rxSndNrCounter == 5 |         |
 *                 |                                              |
 *             </pre></b>
 *
 *             This application is compatible with the following WMBUS meter
 *             demonstration application(s):
 *             - app_aplMeterRtos.c
 *
 *             ## Source Code
 */

/*==============================================================================
                            INCLUDE FILES
==============================================================================*/
/* Standard libraries */
#include <stdint.h>
#include <stdbool.h>

/* XDCtools Header files */
#include <stdlib.h>
#include <xdc/std.h>
#include <xdc/cfg/global.h>
#include <xdc/runtime/System.h>
#include <xdc/runtime/Error.h>

/* BIOS Header files */
#include <ti/sysbios/BIOS.h>
#include <ti/sysbios/knl/Task.h>
#include <ti/drivers/Power.h>

/* Example/Board Header files */
#include "Board.h"
#include "ti_rtos_src/sf_mcu_timerRtos.h"
#include "ti_rtos_src/sf_mcu_rtcRtos.h"

#include "inc/pub/utils/wmbus_timer_api.h"
/* Include common HAL API. */
#include "inc/pub/hal/wmbus_hal.h"
/* Include HAL BSP API */
#include "inc/pub/hal/wmbus_hal_bsp.h"
/* Support low power modes */
#include "inc/pub/hal/wmbus_hal_mcu_sleep.h"
/* Sandman module to support sleep modes. */
#include "src/utils/sandman/src/sf_sandman_api.h"
/* Include common APL API */
#include "inc/pub/apl/wmbus_apl_api.h"
#include "inc/pub/apl/wmbus_apl_indication_api.h"
#include "inc/pub/apl/wmbus_apl_attributes_api.h"
/* Include meter device specific APL API functions */
#include "inc/pub/apl/wmbus_apl_col_api.h"
#include "inc/pub/apl/wmbus_apl_col_attributes_api.h"
#include "inc/pub/apl/wmbus_apl_col_indication_api.h"

#include "wmbus_task.h"
#include "wmbus_semaphore.h"

#include <ti/drivers/UART.h>
#include <ti/drivers/uart/UARTCC26XX.h>

/*==============================================================================
                            DEFINES
==============================================================================*/
#ifndef WMBUS_CFG_DEVICE
  #error Please define the device configuration to a COLLECTOR device!
#elif WMBUS_CFG_DEVICE != WMBUS_CFG_DEVICE_COLLECTOR
  #error Please define the device configuration to a COLLECTOR device!
#endif /* WMBUS_CFG_DEVICE */

/*! Number of received telegrams from meter device until the collector starts
    bidirectional communication by first sending SND-UD to meter. */
#define NUMBER_OF_TELEGRAMS_BEFORE_SND_UD    5

#ifndef CUSTOMER_FREQ_OFFSET
  /*! Customer specific frequency offset. */
  #define CUSTOMER_FREQ_OFFSET 0x00
#endif /* CUSTOMER_FREQ_OFFSET */

/* Check if a specific manufacturer id should be used */
#ifndef MANUFACTURER_ID
  /*! Default manufacturer ID (STACKFORCE) MSB */
  #define MANUFACTURER_ID_H      0xCEU
  /*! Default manufacturer ID (STACKFORCE) LSB */
  #define MANUFACTURER_ID_L      0x86U
  #warning MANUFACTURER_ID is not defined. Default manufacturer ID 0xCE86 (STF) is used
#else
  /* Set the ID of the manufacturer */
  #define MANUFACTURER_ID_H      (uint8_t)((MANUFACTURER_ID & 0xFF00U)>>8)
  #define MANUFACTURER_ID_L      (uint8_t)(MANUFACTURER_ID & 0x00FFU)
#endif /* MANUFACTURER_ID */

/*! Max length of the payload:
    MAX_PAYLOAD_LEN = 255-9(Dll-Header->L field not counted)-1(CI-Field) */
#define MAX_PAYLOAD_LEN (uint8_t)245U

/*==============================================================================
                            VARIABLES
==============================================================================*/
/*! Counts the received SND-NR messages. */
uint8_t gc_rxSndNrCounter = 0;

/*! Memory to store received telegrams. */
uint8_t gac_telegramStorage[MAX_PAYLOAD_LEN];

/*! Example collector address */
s_wmbus_addr_t gs_collector = {{MANUFACTURER_ID_H, MANUFACTURER_ID_L},
                    {0x80,0x00,0x00,0x02},    /* ident number            */
                     0x23,                    /* version                 */
                    WMBUS_DEV_TYPE_OTHER};    /* type, here other        */

/*! Example meter entry for the meterlist of the collector. */
s_apl_meterEntry_t gs_meterEntry = {
                /* WMBus meter address */
                {{MANUFACTURER_ID_H, MANUFACTURER_ID_L},{0x80,0x00,0x00,0x01},0x23,WMBUS_DEV_TYPE_WATER},
                /* WMBus mode of the meter */
                E_WMBUS_MODE_UNKNOWN,
                /* WMBus RF adapter address of the meter (unused) */
                {{0x0,0x0},{0x0,0x0,0x0,0x0},0x0,0x0},
                /* WMBus meter key */
                {0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,
                 0x88,0x99,0xAA,0xBB,0xCC,0xDD,0xEE,0xFF}};

/*! Example meterlist */
s_apl_meterList_t gs_meterList = {0x0001U, &gs_meterEntry};

/*! Start attribute for the collector device.  */
s_apl_colInitAttr_t gs_collectorInitAttr =
{
  {
    /* Frequency offset for the carrier. */
    CUSTOMER_FREQ_OFFSET,
    /* Device address */
    &gs_collector,
    /* Telegram storage */
    gac_telegramStorage,
    /* Size of the telegram storage */
    MAX_PAYLOAD_LEN
  },
  /* Static meters to install at startup. If no static meters are available,
     set the parameter to NULL. Only for collector devices. */
  &gs_meterList
};

/* Flag that indicates that the stack is active (needs to run) or not */
static bool gb_stackActive = true;
/* Variable to store the sleep mode that sandman indicates */
static E_SANDMAN_t ge_sleepMode;

/*==============================================================================
                            FUNCTION PROTOTYPES
==============================================================================*/
/*! Sleep function to be registered to sandman module. */
static void loc_stackSleep(E_SANDMAN_t e_sleep);
/*! Wake up function to be registered to sandman module. */
static void loc_stackWakeUp(void);

/*! Task to handle the wmbus stack */
static void loc_collectorTask(UArg arg0, UArg arg1);

/*==============================================================================
                            LOCAL FUNCTIONS
==============================================================================*/
/*----------------------------------------------------------------------------*/
/*
 * @brief Sleep function to be registered to sandman module.
 *
 * @param e_sleep This parameter specifies the deepest sleep mode which is
                  currently possible.
 */
/*----------------------------------------------------------------------------*/
static void loc_stackSleep(E_SANDMAN_t e_sleep)
{
  gb_stackActive = false;
  ge_sleepMode = e_sleep;
} /* loc_stackSleep() */

/*----------------------------------------------------------------------------*/
/*!
 * @brief Wake up function to be registered to sandman module.
 */
/*----------------------------------------------------------------------------*/
static void loc_stackWakeUp(void)
{
  gb_stackActive = true;
} /* loc_stackWakeUp() */

uint8_t g_version_string[50];

/*----------------------------------------------------------------------------*/
/*!
 * @brief Task to handle the wmbus stack.
 */
/*----------------------------------------------------------------------------*/
static void loc_collectorTask(UArg arg0, UArg arg1)
{
  /* Initialises the hal. */
  if(wmbus_hal_init() == E_HAL_STATUS_SUCCESS)
  {
    /* Initialize the sandman module. */
    sf_sandman_init(&loc_stackSleep, &loc_stackWakeUp);

    /* Disable sleep mode for collector devices to ensure a faster reaction during
     * bidirectional communication */
    Power_disablePolicy();

    /* Initialize APL */
    if(E_WMBUS_STATUS_SUCCESS == wmbus_apl_col_init(&gs_collectorInitAttr))
    {
      #if WMBUS_CHECK_MODE_or(WMBUS_MODE_N1 | WMBUS_MODE_N2)
        /* Set the channel which should be used (for mode N-Devices only) */
        wmbus_apl_setChannelN(E_WMBUS_N_CHANNEL_169_1A);
      #endif /* WMBUS_CHECK_MODE_or(WMBUS_MODE_N1 | WMBUS_MODE_N2) */

      if (!wmbus_getVersionString(g_version_string, 50)) {
          while(true){}
      }
      if (g_version_string[0] != '2' ||
          g_version_string[1] != '.' ||
          g_version_string[2] != '0' ||
          g_version_string[3] != '.' ||
          g_version_string[4] != '0' ||
          g_version_string[5] != '\0'
         ) {
          while(true){}
      }

      if(E_WMBUS_STATUS_SUCCESS != wmbus_apl_col_setProperty(E_APL_COL_PROPERTY_ENHANCED_INSTALLATION, true)) {
          while(true){}
      }

      if (E_WMBUS_STATUS_SUCCESS != wmbus_memoryErase()) {
          while(true){}
      }
      if (E_WMBUS_STATUS_SUCCESS != wmbus_memorySynchronization()) {
          while(true){}
      }

      while(true)
      {
        // Don't go to sleep
        if(gb_stackActive || true)
        {
          sf_mcu_rtc_run();

          /*
             Run the application layer.
             In general, the function wmbus_apl_col_run must be called as often as
             possible, since it is responsible to handle all operations of the
             WMBUS Stack.
          */
          wmbus_apl_col_run();

          /* handel target events */
          wmbus_hal_bsp_handleEvent();
        }
        else
        {
          /* It is possible to let the device go to sleep. */
          wmbus_hal_mcu_sleep((E_HAL_MCU_SLEEP_MODE_t) ge_sleepMode);
        } /* if() .. else */
      }/* while */
    } /* if */
    else
    {
      /* Stack initialization failed. Add your error handling here. */
      while(1);
    }/* if...else */
  } /* if */
  else
  {
    /* HAL initialization failed. Add your error handling here. */
    while(1);
  }/* if() .. else */
}/* loc_collectorTask() */

/*==============================================================================
                            FUNCTIONS
==============================================================================*/
/*============================================================================*/
/*!
 * @brief Main program.
 */
/*============================================================================*/
int main(void)
{
  Error_Block eb;

  /* Call board init functions */
  Board_initGeneral();

  /* Initialize error parameters */
  Error_init(&eb);

  wmbus_task_init(loc_collectorTask, &eb);
  wmbus_semaphore_init(&eb);
  /* Initialize the periodical clock source of the wmbus stack */
  sf_mcu_timerRtos_init(TMR_TICKS_PER_SECOND, &eb);
  sf_mcu_rtc_init();

  /* Start BIOS */
  BIOS_start();
  return (0);
} /* main() */

/*----------------------------------------------------------------------------*/
/* wmbus_apl_indication() */
/*----------------------------------------------------------------------------*/
void wmbus_apl_indication(E_APL_INDICATION_t e_indication)
{
  switch(e_indication)
  {
    case E_APL_INDICATION_TX:
      break;
    case E_APL_INDICATION_TX_ERROR:
      break;
    case E_APL_INDICATION_REQUEST_TIMEOUT:
      break;
    case E_APL_INDICATION_RX_BUFFER_OVERFLOW:
      break;
    case E_APL_INDICATION_RX_NO_TELEGRAM_STORAGE:
      break;
    case E_APL_INDICATION_RX_TELEGRAM_STORAGE_OVERFLOW:
      break;
    default:
      break;
  }
}/* wmbus_apl_indication() */

/*----------------------------------------------------------------------------*/
/* wmbus_apl_col_indication() */
/*----------------------------------------------------------------------------*/
void wmbus_apl_col_indication(E_APL_COL_INDICATION_t e_indication,
                              uint16_t i_meterId)
{
  switch(e_indication)
  {
    case E_APL_COL_ALARM_AVAILABLE:
      break;
    case E_APL_COL_RX_DECRYPTION_FAILED:
      break;
    case E_APL_COL_RX_UNKNOWN_ENCRYPTION:
      break;
    default:
      break;
  }
}/* wmbus_apl_col_indication() */

/*----------------------------------------------------------------------------*/
/* wmbus_apl_col_indication_rx() */
/*----------------------------------------------------------------------------*/
void wmbus_apl_col_indication_rx(uint16_t i_meterId,
                                 E_APL_MESSAGE_TYPE_t e_controlField,
                                 uint8_t c_rssi, E_WMBUS_FRAME_t e_frameFormat,
                                 E_WMBUS_MODE_t e_mode,
                                 s_wmbus_layerHeaderLength_t *ps_headerLen,
                                 uint8_t *pc_payload, uint16_t i_length)
{
  /* SND-UD payload. */
  uint8_t ac_cmdPayload[] = { 0x0F,  /* Record 1: DIB: Manufacturer specific data structure */
                              0x7F,  /* Record 1: VIB: Manufacturer specific */
                              0x00,  /* Record 1: Dummy data */
                              0x01,  /* Record 1: Dummy data */
                              0x02,  /* Record 1: Dummy data */
                              0x03,  /* Record 1: Dummy data */
                              0x04}; /* Record 1: Dummy data */

  if(e_controlField == E_APL_MESSAGE_TYPE_SND_NR)
  {
    /* SND-NR telegram received. Increase the counter. */
    ++gc_rxSndNrCounter;

    if(gc_rxSndNrCounter == NUMBER_OF_TELEGRAMS_BEFORE_SND_UD)
    {
      /* Threshold reached. Initiate transmission of a SND-UD telegram. */
      wmbus_apl_col_sendUserData(E_APL_MESSAGE_TYPE_SND_UD,
                                 APL_FIELD_CI_CMD_TO_DEVICE_LONG, i_meterId,
                                 true, 0xFFFFU, ac_cmdPayload, sizeof(ac_cmdPayload));
      /* Reset the counter. */
      gc_rxSndNrCounter = 0U;
    }
  }
  else if(e_controlField == E_APL_MESSAGE_TYPE_ACK)
  {
    /* ACK telegram from the meter received. Send SND-NKE. */
    wmbus_apl_col_send(E_APL_MESSAGE_TYPE_SND_NKE,
                       APL_FIELD_CI_LINK_TO_DEVICE_LONG,
                       i_meterId, true);
  }
}/* wmbus_apl_col_indication_rx() */

/*----------------------------------------------------------------------------*/
/* wmbus_apl_col_indication_tlgPrependedToQueue() */
/*----------------------------------------------------------------------------*/
void wmbus_apl_col_indication_tlgPrependedToQueue(uint16_t i_meterId,
                                                  E_APL_MESSAGE_TYPE_t e_controlField)
{
  /*
   * A telegram from the given telegram type has been automatically
   * created by the Wireless M-Bus stack and added to the telegram queue.
   */
}/* wmbus_apl_col_indication_tlgPrependedToQueue() */

uint16_t g_last_len;
uint8_t g_payload[256];

/*----------------------------------------------------------------------------*/
/* wmbus_apl_col_indication_newMeter() */
/*----------------------------------------------------------------------------*/
void wmbus_apl_col_indication_newMeter(s_wmbus_addr_t * ps_address,
                                       s_wmbus_addr_t * ps_rfAdapter,
                                       E_WMBUS_MODE_t e_mode,
                                       E_WMBUS_FRAME_t e_frameFormat,
                                       uint8_t c_rssi,
                                       s_wmbus_layerHeaderLength_t * ps_headerLen,
                                       uint8_t * pc_payload, uint16_t i_len)
{

  if (E_WMBUS_MODE_T == e_mode) {
      for (size_t i=0; i<256; ++i) {
          g_payload[i] = 0;
      }
      g_last_len = i_len;
      for (size_t i=0; i<i_len; ++i) {
          g_payload[i] = pc_payload[i];
      }

      g_payload[255] = 0;
  }

}/* wmbus_apl_col_indication_newMeter() */

#if OMS_V4_ENABLED
#if INVALID_MSG_CTR_EVENT_ENABLED
/*----------------------------------------------------------------------------*/
/* wmbus_apl_col_indication_invalidMsgCtrReceived() */
/*----------------------------------------------------------------------------*/
void wmbus_apl_col_indication_invalidMsgCtrReceived(uint16_t i_meterId,
                                                    uint32_t l_invalidMsgCtr)
{
  /* The event is triggered to inform the upper layer that an OMSv.4 telegram
     is received with invalid message counter. */
  return;
} /* wmbus_apl_col_indication_invalidMsgCtrReceived() */
#endif /* INVALID_MSG_CTR_EVENT_ENABLED */
#endif /* OMS_V4_ENABLED */