antenna_isis.hpp

Go to the documentation of this file.

/*
 *  SatNOGS-COMMS control library
 *
 *  Copyright (C) 2025, Libre Space Foundation <http://libre.space>
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *  SPDX-License-Identifier: GNU General Public License v3.0 or later
 */
 
#pragma once
 
#include <cstdint>
#include <initializer_list>
#include <satnogs-comms-lib/antenna.hpp>
#include <satnogs-comms-lib/bsp/gpio.hpp>
#include <satnogs-comms-lib/bsp/i2c.hpp>
 
namespace satnogs::comms::lib
{

template <uint32_t N> class antenna_isis : public antenna
{
public:
  enum class cmd : uint8_t
  {
    CANCEL                      = 0xA9,
    DISARM                      = 0xAC,
    ARM                         = 0xAD,
    DEPLOY_ANT1_OVERRIDE        = 0xBA,
    DEPLOY_ANT2_OVERRIDE        = 0xBB,
    DEPLOY_ANT1_OVERRIDE_BACKUP = 0xBC,
    DEPLOY_ANT2_OVERRIDE_BACKUP = 0xBD,
    TEMPERATURE                 = 0xC0,
    DEPLOYMENT_STATUS           = 0xC3,
    UPTIME                      = 0xC6,
    ALL                         = 0xC7
  };

  antenna_isis(const etl::istring &name, bsp::i2c &i2c, uint16_t addr,
               bsp::gpio &pwr)
      : antenna(name, N), m_addr(addr), m_i2c(i2c), m_pwr(pwr)
  {
    static_assert(N > 0, "At least one IO configuration should be set");
  }
 
  void
  enable(bool en) override
  {
    m_pwr.set(en);
  }
 
  bool
  detect(uint32_t idx) override
  {
    bool x = false;
    telemetry(scl::antenna::tlm::DEPLOYED, idx, x);
    return x;
  }
 
  void
  deploy(uint32_t idx, bool en) override
  {
    if (idx > 1) {
      throw scl::inval_arg_exception(__FILE__, __LINE__);
    }
 
    std::array<uint8_t, 4> txbuf{};
    if (en) {
      /* To deploy the any of the antennas, the system should be armed */
      txbuf[0] = static_cast<uint8_t>(cmd::ARM);
      m_i2c.write(m_addr, txbuf.data(), 1);
      txbuf[0] = static_cast<uint8_t>(idx == 0 ? cmd::DEPLOY_ANT1_OVERRIDE
                                               : cmd::DEPLOY_ANT2_OVERRIDE);
      /* Use safety time */
      txbuf[1] = 0;
      m_i2c.write(m_addr, txbuf.data(), 2);
    } else {
      txbuf[0] = static_cast<uint8_t>(cmd::CANCEL);
      m_i2c.write(m_addr, txbuf.data(), 1);
      txbuf[0] = static_cast<uint8_t>(cmd::DISARM);
      m_i2c.write(m_addr, txbuf.data(), 1);
    }
  }
 
  void
  telemetry(tlm t, uint32_t &res)
  {
    std::array<uint8_t, 4> txbuf{};
    std::array<uint8_t, 4> rxbuf{};
 
    switch (t) {
    case tlm::UPTIME:
      txbuf[0] = static_cast<uint8_t>(cmd::UPTIME);
      m_i2c.read(m_addr, rxbuf.data(), 4, txbuf.data(), 1);
      res = (rxbuf[3] << 24) | (rxbuf[2] << 16) | (rxbuf[1] << 8) | rxbuf[0];
      break;
    default:
      throw scl::inval_arg_exception(__FILE__, __LINE__);
    }
  }
 
  void
  telemetry(tlm t, float &res) override
  {
 
    std::array<uint8_t, 2>  txbuf{};
    std::array<uint8_t, 11> rxbuf{};
 
    switch (t) {
    case tlm::TEMPERATURE: {
      txbuf[0] = static_cast<uint8_t>(cmd::TEMPERATURE);
      m_i2c.read(m_addr, rxbuf.data(), 2, txbuf.data(), 1);
      uint32_t x = (rxbuf[1] << 8) | rxbuf[0];
      /* Only 10-bits are relevant */
      x &= 0x3FF;
      double mV = (3.3 / 1024) * x * 1000.0;
      /*
       * Convert to Celsius. Slope and intercept point has been calculated by
       * linear regression of the Table 8-2 of the ICD
       */
      res = mV * -0.09067242916 + 190.15431352;
      break;
    }
    case tlm::VOLTAGE: {
      txbuf[0] = static_cast<uint8_t>(cmd::ALL);
      m_i2c.read(m_addr, rxbuf.data(), 11, txbuf.data(), 1);
      uint32_t x = (rxbuf[3] << 8) | rxbuf[2];
      /* Only 10-bits are relevant */
      x &= 0x3FF;
      /*
       * Fullscale empirically retrieved after measuring the voltage on the
       * connector of the antenna taking into account the cable voltage drop.
       * The datasheet does not specify the correct formula.
       */
      res = (20.0 / 1024.0) * x;
      break;
    }
 
    default:
      throw scl::inval_arg_exception(__FILE__, __LINE__);
    }
  }
 
  void
  telemetry(tlm t, uint32_t idx, bool &res) override
  {
 
    std::array<uint8_t, 4> txbuf{};
    std::array<uint8_t, 4> rxbuf{};
 
    if (idx > 1) {
      throw scl::inval_arg_exception(__FILE__, __LINE__);
    }
 
    switch (t) {
    case tlm::DEPLOYED: {
      txbuf[0] = static_cast<uint8_t>(cmd::DEPLOYMENT_STATUS);
      m_i2c.read(m_addr, rxbuf.data(), 2, txbuf.data(), 1);
      /* Switch has inverted logic */
      if (idx == 0) {
        res = !(rxbuf[1] >> 7);
      } else {
        res = !((rxbuf[1] >> 3) & 0x1);
      }
      break;
    }
    default:
      throw scl::inval_arg_exception(__FILE__, __LINE__);
    }
  }
 
private:
  const uint16_t m_addr;
  bsp::i2c      &m_i2c;
  bsp::gpio     &m_pwr;
};

} // namespace satnogs::comms::lib