MAXREFDES143#: DeepCover Embedded Security in IoT Authenticated Sensing & Notification

Dependencies:   MaximInterface mbed

The MAXREFDES143# is an Internet of Things (IoT) embedded security reference design, built to protect an industrial sensing node by means of authentication and notification to a web server. The hardware includes a peripheral module representing a protected sensor node monitoring operating temperature and remaining life of a filter (simulated through ambient light sensing) and an mbed shield representing a controller node responsible for monitoring one or more sensor nodes. The design is hierarchical with each controller node communicating data from connected sensor nodes to a web server that maintains a centralized log and dispatches notifications as necessary. The mbed shield contains a Wi-Fi module, a DS2465 coprocessor with 1-Wire® master function, an LCD, LEDs, and pushbuttons. The protected sensor node contains a DS28E15 authenticator, a DS7505 temperature sensor, and a MAX44009 light sensor. The mbed shield communicates to a web server by the onboard Wi-Fi module and to the protected sensor node with I2C and 1-Wire. The MAXREFDES143# is equipped with a standard shield connector for immediate testing using an mbed board such as the MAX32600MBED#. The simplicity of this design enables rapid integration into any star-topology IoT network requiring the heightened security with low overhead provided by the SHA-256 symmetric-key algorithm.

More information about the MAXREFDES143# is available on the Maxim Integrated website.

DS7505.cpp

Committer:
IanBenzMaxim
Date:
19 months ago
Revision:
35:3d414ba9ab6c
Parent:
32:0a09505a656d

File content as of revision 35:3d414ba9ab6c:

/*******************************************************************************
* Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
* OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* Except as contained in this notice, the name of Maxim Integrated
* Products, Inc. shall not be used except as stated in the Maxim Integrated
* Products, Inc. Branding Policy.
*
* The mere transfer of this software does not imply any licenses
* of trade secrets, proprietary technology, copyrights, patents,
* trademarks, maskwork rights, or any other form of intellectual
* property whatsoever. Maxim Integrated Products, Inc. retains all
* ownership rights.
*******************************************************************************/

#include <I2C.h>
#include <wait_api.h>
#include "DS7505.hpp"

static const int I2C_Write_Ok = 1;
static const uint8_t DS7505_Config_SD_Bit = 0x01; // Enable shutdown mode

DS7505::DS7505(mbed::I2C & I2C_interface, uint8_t I2C_address)
    : m_current_config(Config_9b_Res, true), m_I2C_interface(I2C_interface),
      m_I2C_address(I2C_address) {}

uint8_t DS7505::get_measure_delay_ms(Config_Resolution resolution) {
  uint8_t measure_delay_ms;

  switch (resolution) {
  case Config_9b_Res:
    measure_delay_ms = 25;
    break;
  case Config_10b_Res:
    measure_delay_ms = 50;
    break;
  case Config_11b_Res:
    measure_delay_ms = 100;
    break;
  case Config_12b_Res:
    measure_delay_ms = 200;
    break;
  default:
    measure_delay_ms = 0;
    break;
  }

  return measure_delay_ms;
}

bool DS7505::read_temp_sensor_data(uint16_t & sensor_data) const {
  bool result;
  uint8_t upperByte, lowerByte;
  int sub_res;

  sensor_data = 0;
  m_I2C_interface.start();
  sub_res = m_I2C_interface.write(m_I2C_address | 1);
  if (sub_res == I2C_Write_Ok) {
    upperByte = m_I2C_interface.read(mbed::I2C::ACK);
    lowerByte = m_I2C_interface.read(mbed::I2C::NoACK);
  }
  m_I2C_interface.stop();
  if (sub_res == I2C_Write_Ok) {
    sensor_data = ((((uint16_t)upperByte) << 8) | lowerByte);
    result = true;
  } else {
    // Handle hardware malfunction
    result = false;
  }

  return result;
}

bool DS7505::set_register_pointer(Register pointer_reg) const {
  int res;

  m_I2C_interface.start();
  res = m_I2C_interface.write(m_I2C_address);
  if (res == I2C_Write_Ok) {
    res = m_I2C_interface.write(pointer_reg);
  }
  m_I2C_interface.stop();

  return (res == I2C_Write_Ok);
}

bool DS7505::write_register(Register write_reg, uint8_t write_val) const {
  bool res;

  m_I2C_interface.start();
  res = m_I2C_interface.write(m_I2C_address);
  if (res == I2C_Write_Ok) {
    res = m_I2C_interface.write(write_reg);
    if (res == I2C_Write_Ok)
      res = m_I2C_interface.write(write_val);
  }
  m_I2C_interface.stop();

  return (res == I2C_Write_Ok);
}

bool DS7505::write_current_config() const {
  uint8_t DS7505_Config_Val = m_current_config.resolution;
  if (m_current_config.enable_shutdown_mode)
    DS7505_Config_Val |= DS7505_Config_SD_Bit;
  return write_register(Configuration_Reg, DS7505_Config_Val);
}

DS7505::Result DS7505::set_resolution(uint8_t resolution) {
  switch (resolution) {
  case 1:
    m_current_config.resolution = Config_9b_Res;
    break;
  case 2:
    m_current_config.resolution = Config_10b_Res;
    break;
  case 3:
    m_current_config.resolution = Config_11b_Res;
    break;
  case 4:
    m_current_config.resolution = Config_12b_Res;
    break;
  default:
    return Out_of_Range;
  }

  // Write DS7505 configuration
  if (!write_current_config()) {
    // Handle hardware malfunction
    return Hardware_Failure;
  }

  // Set pointer to temperature register
  if (!set_register_pointer(Temperature_Reg)) {
    // Handle hardware malfunction
    return Hardware_Failure;
  }

  return Success;
}

DS7505::Result DS7505::read_temp_sensor(uint16_t & sensor_data) const {
  bool res;

  if (m_current_config.enable_shutdown_mode) {
    // Disable shutdown mode
    m_current_config.enable_shutdown_mode = false;
    res = write_current_config();
    if (!res)
      return Hardware_Failure;

    // DS7505 measures temperature

    // Enable shutdown mode
    m_current_config.enable_shutdown_mode = true;
    res = write_current_config();
    if (!res)
      return Hardware_Failure;

    // Set pointer to temperature register
    res = set_register_pointer(Temperature_Reg);
    if (!res)
      return Hardware_Failure;

    // Sleep for maximum time needed for sample
    wait_ms(get_measure_delay_ms(m_current_config.resolution));
  }
  // else: shutdown mode disabled
  //    DS7505 is constantly measuring temperature

  // Read temperature from sensor
  if (!read_temp_sensor_data(sensor_data)) {
    return Hardware_Failure;
  }

  return Success;
}

DS7505::Result DS7505::read_current_temp(int16_t & temperature) const {
  uint16_t sensor_data;
  Result result;

  result = read_temp_sensor(sensor_data);
  if (result == Success) {
    // Convert temperature to have an exponent of 10^-2
    temperature = ((int8_t)(sensor_data >> 8)) * 100;
    if (sensor_data & 0x0080)
      temperature += 50; // 0.5
    if (sensor_data & 0x0040)
      temperature += 25; // 0.25
    if (sensor_data & 0x0020)
      temperature += 13; // 0.125
    if (sensor_data & 0x0010)
      temperature += 6; // 0.0625
  }
  return result;
}

DS7505::Result DS7505::read_current_temp(double & temperature) const {
  uint16_t sensor_data;
  Result result;

  result = read_temp_sensor(sensor_data);
  if (result == Success) {
    // Convert sensor data to floating-point temperature
    temperature = ((int8_t)(sensor_data >> 8));
    if (sensor_data & 0x0080)
      temperature += 0.5;
    if (sensor_data & 0x0040)
      temperature += 0.25;
    if (sensor_data & 0x0020)
      temperature += 0.125;
    if (sensor_data & 0x0010)
      temperature += 0.0625;
  }
  return result;
}

DS7505::Result DS7505::read_current_temp(int8_t & temperature) const {
  uint16_t sensor_data;
  Result result;

  result = read_temp_sensor(sensor_data);
  if (result == Success) {
    // Convert sensor data to integer temperature
    temperature = ((int8_t)(sensor_data >> 8));
  }
  return result;
}