eive-obsw/mission/acs/str/strJsonCommands.cpp

#include <mission/acs/str/arcsecJsonKeys.h>
#include <mission/acs/str/strJsonCommands.h>

#include "arcsecJsonKeys.h"

Limits::Limits() : ArcsecJsonParamBase(arcseckeys::LIMITS) {}

size_t Limits::getSize() { return COMMAND_SIZE; }

ReturnValue_t Limits::createCommand(uint8_t* buffer) {
  ReturnValue_t result = returnvalue::OK;
  uint8_t offset = 0;
  std::string param;
  addSetParamHeader(buffer, startracker::ID::LIMITS);
  offset = 2;
  result = getParam(arcseckeys::ACTION, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::FPGA18CURRENT, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::FPGA25CURRENT, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::FPGA10CURRENT, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::MCUCURRENT, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::CMOS21CURRENT, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::CMOSPIXCURRENT, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::CMOS33CURRENT, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::CMOSVRESCURRENT, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::CMOS_TEMPERATURE, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::MCU_TEMPERATURE, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  return returnvalue::OK;
}

Tracking::Tracking() : ArcsecJsonParamBase(arcseckeys::TRACKING) {}

size_t Tracking::getSize() { return COMMAND_SIZE; }

ReturnValue_t Tracking::createCommand(uint8_t* buffer) {
  ReturnValue_t result = returnvalue::OK;
  uint8_t offset = 0;
  std::string param;
  addSetParamHeader(buffer, startracker::ID::TRACKING);
  offset = 2;
  result = getParam(arcseckeys::THIN_LIMIT, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::OUTLIER_THRESHOLD, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::OUTLIER_THRESHOLD_QUEST, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::TRACKER_CHOICE, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  return returnvalue::OK;
}

Mounting::Mounting() : ArcsecJsonParamBase(arcseckeys::MOUNTING) {}

size_t Mounting::getSize() { return COMMAND_SIZE; }

ReturnValue_t Mounting::createCommand(uint8_t* buffer) {
  ReturnValue_t result = returnvalue::OK;
  uint8_t offset = 0;
  std::string param;
  addSetParamHeader(buffer, startracker::ID::MOUNTING);
  offset = 2;
  result = getParam(arcseckeys::qw, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::qx, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::qy, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::qz, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  return returnvalue::OK;
}

ImageProcessor::ImageProcessor() : ArcsecJsonParamBase(arcseckeys::IMAGE_PROCESSOR) {}

size_t ImageProcessor::getSize() { return COMMAND_SIZE; }

ReturnValue_t ImageProcessor::createCommand(uint8_t* buffer) {
  ReturnValue_t result = returnvalue::OK;
  uint8_t offset = 0;
  std::string param;
  addSetParamHeader(buffer, startracker::ID::IMAGE_PROCESSOR);
  offset = 2;
  result = getParam(arcseckeys::IMAGE_PROCESSOR_MODE, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::STORE, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::SIGNAL_THRESHOLD, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint16(param, buffer + offset);
  offset += sizeof(uint16_t);
  result = getParam(arcseckeys::IMAGE_PROCESSOR_DARK_THRESHOLD, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint16(param, buffer + offset);
  offset += sizeof(uint16_t);
  result = getParam(arcseckeys::BACKGROUND_COMPENSATION, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  return returnvalue::OK;
}

Camera::Camera() : ArcsecJsonParamBase(arcseckeys::CAMERA) {}

size_t Camera::getSize() { return COMMAND_SIZE; }

ReturnValue_t Camera::createCommand(uint8_t* buffer) {
  ReturnValue_t result = returnvalue::OK;
  uint8_t offset = 0;
  std::string param;
  addSetParamHeader(buffer, startracker::ID::CAMERA);
  offset = 2;
  result = getParam(arcseckeys::MODE, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::FOCALLENGTH, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::EXPOSURE, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::INTERVAL, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::OFFSET, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addint16(param, buffer + offset);
  offset += sizeof(int16_t);
  result = getParam(arcseckeys::PGAGAIN, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::ADCGAIN, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::REG_1, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::VAL_1, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::REG_2, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::VAL_2, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::REG_3, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::VAL_3, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::REG_4, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::VAL_4, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::REG_5, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::VAL_5, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::REG_6, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::VAL_6, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::REG_7, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::VAL_7, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::REG_8, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::VAL_8, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::FREQ_1, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint32(param, buffer + offset);
  return returnvalue::OK;
}

Centroiding::Centroiding() : ArcsecJsonParamBase(arcseckeys::CENTROIDING) {}

size_t Centroiding::getSize() { return COMMAND_SIZE; }

ReturnValue_t Centroiding::createCommand(uint8_t* buffer) {
  ReturnValue_t result = returnvalue::OK;
  uint8_t offset = 0;
  std::string param;
  addSetParamHeader(buffer, startracker::ID::CENTROIDING);
  offset = 2;
  result = getParam(arcseckeys::ENABLE_FILTER, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::MAX_QUALITY, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::DARK_THRESHOLD, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::MIN_QUALITY, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::MAX_INTENSITY, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::MIN_INTENSITY, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::MAX_MAGNITUDE, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::GAUSSIAN_CMAX, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::GAUSSIAN_CMIN, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::TRANSMATRIX_00, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::TRANSMATRIX_01, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::TRANSMATRIX_10, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::TRANSMATRIX_11, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  return returnvalue::OK;
}

Lisa::Lisa() : ArcsecJsonParamBase(arcseckeys::LISA) {}

size_t Lisa::getSize() { return COMMAND_SIZE; }

ReturnValue_t Lisa::createCommand(uint8_t* buffer) {
  ReturnValue_t result = returnvalue::OK;
  uint8_t offset = 0;
  std::string param;
  addSetParamHeader(buffer, startracker::ID::LISA);
  offset = 2;
  result = getParam(arcseckeys::LISA_MODE, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint32(param, buffer + offset);
  offset += sizeof(uint32_t);
  result = getParam(arcseckeys::PREFILTER_DIST_THRESHOLD, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::PREFILTER_ANGLE_THRESHOLD, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::FOV_WIDTH, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::FOV_HEIGHT, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::FLOAT_STAR_LIMIT, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::CLOSE_STAR_LIMIT, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::RATING_WEIGHT_CLOSE_STAR_COUNT, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::RATING_WEIGHT_FRACTION_CLOSE, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::RATING_WEIGHT_MEAN_SUM, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::RATING_WEIGHT_DB_STAR_COUNT, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::MAX_COMBINATIONS, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::NR_STARS_STOP, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::FRACTION_CLOSE_STOP, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  return returnvalue::OK;
}

Matching::Matching() : ArcsecJsonParamBase(arcseckeys::MATCHING) {}

size_t Matching::getSize() { return COMMAND_SIZE; }

ReturnValue_t Matching::createCommand(uint8_t* buffer) {
  ReturnValue_t result = returnvalue::OK;
  uint8_t offset = 0;
  std::string param;
  addSetParamHeader(buffer, startracker::ID::MATCHING);
  offset = 2;
  result = getParam(arcseckeys::SQUARED_DISTANCE_LIMIT, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::SQUARED_SHIFT_LIMIT, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  return returnvalue::OK;
}

Validation::Validation() : ArcsecJsonParamBase(arcseckeys::VALIDATION) {}

size_t Validation::getSize() { return COMMAND_SIZE; }

ReturnValue_t Validation::createCommand(uint8_t* buffer) {
  ReturnValue_t result = returnvalue::OK;
  uint8_t offset = 0;
  std::string param;
  addSetParamHeader(buffer, startracker::ID::VALIDATION);
  offset = 2;
  result = getParam(arcseckeys::STABLE_COUNT, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::MAX_DIFFERENCE, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::MIN_TRACKER_CONFIDENCE, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::MIN_MATCHED_STARS, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  return returnvalue::OK;
}

Algo::Algo() : ArcsecJsonParamBase(arcseckeys::ALGO) {}

size_t Algo::getSize() { return COMMAND_SIZE; }

ReturnValue_t Algo::createCommand(uint8_t* buffer) {
  ReturnValue_t result = returnvalue::OK;
  uint8_t offset = 0;
  std::string param;
  addSetParamHeader(buffer, startracker::ID::ALGO);
  offset = 2;
  result = getParam(arcseckeys::MODE, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::L2T_MIN_CONFIDENCE, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::L2T_MIN_MATCHED, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::T2L_MIN_CONFIDENCE, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  offset += sizeof(float);
  result = getParam(arcseckeys::T2L_MIN_MATCHED, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  return returnvalue::OK;
}

LogLevel::LogLevel() : ArcsecJsonParamBase(arcseckeys::LOGLEVEL) {}

size_t LogLevel::getSize() { return COMMAND_SIZE; }

ReturnValue_t LogLevel::createCommand(uint8_t* buffer) {
  ReturnValue_t result = returnvalue::OK;
  uint8_t offset = 0;
  std::string param;
  addSetParamHeader(buffer, startracker::ID::LOG_LEVEL);
  offset = 2;
  result = getParam(arcseckeys::LOGLEVEL1, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::LOGLEVEL2, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::LOGLEVEL3, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::LOGLEVEL4, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::LOGLEVEL5, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::LOGLEVEL6, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::LOGLEVEL7, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::LOGLEVEL8, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::LOGLEVEL9, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::LOGLEVEL10, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::LOGLEVEL11, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::LOGLEVEL12, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::LOGLEVEL13, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::LOGLEVEL14, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::LOGLEVEL15, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::LOGLEVEL16, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);

  return returnvalue::OK;
}

Subscription::Subscription() : ArcsecJsonParamBase(arcseckeys::SUBSCRIPTION) {}

size_t Subscription::getSize() { return COMMAND_SIZE; }

ReturnValue_t Subscription::createCommand(uint8_t* buffer) {
  ReturnValue_t result = returnvalue::OK;
  uint8_t offset = 0;
  std::string param;
  addSetParamHeader(buffer, startracker::ID::SUBSCRIPTION);
  offset = 2;
  result = getParam(arcseckeys::TELEMETRY_1, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::TELEMETRY_2, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::TELEMETRY_3, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::TELEMETRY_4, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::TELEMETRY_5, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::TELEMETRY_6, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::TELEMETRY_7, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::TELEMETRY_8, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::TELEMETRY_9, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::TELEMETRY_10, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::TELEMETRY_11, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::TELEMETRY_12, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::TELEMETRY_13, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::TELEMETRY_14, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::TELEMETRY_15, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::TELEMETRY_16, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  return returnvalue::OK;
}

LogSubscription::LogSubscription() : ArcsecJsonParamBase(arcseckeys::LOG_SUBSCRIPTION) {}

size_t LogSubscription::getSize() { return COMMAND_SIZE; }

ReturnValue_t LogSubscription::createCommand(uint8_t* buffer) {
  ReturnValue_t result = returnvalue::OK;
  uint8_t offset = 0;
  std::string param;
  addSetParamHeader(buffer, startracker::ID::LOG_SUBSCRIPTION);
  offset = 2;
  result = getParam(arcseckeys::LEVEL1, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::MODULE1, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::LEVEL2, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += sizeof(uint8_t);
  result = getParam(arcseckeys::MODULE2, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  return returnvalue::OK;
}

DebugCamera::DebugCamera() : ArcsecJsonParamBase(arcseckeys::DEBUG_CAMERA) {}

size_t DebugCamera::getSize() { return COMMAND_SIZE; }

ReturnValue_t DebugCamera::createCommand(uint8_t* buffer) {
  ReturnValue_t result = returnvalue::OK;
  uint8_t offset = 0;
  std::string param;
  addSetParamHeader(buffer, startracker::ID::DEBUG_CAMERA);
  offset = 2;
  result = getParam(arcseckeys::TIMING, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint32(param, buffer + offset);
  offset += sizeof(uint32_t);
  result = getParam(arcseckeys::TEST, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint32(param, buffer + offset);
  return returnvalue::OK;
}

AutoThreshold::AutoThreshold() : ArcsecJsonParamBase(arcseckeys::AUTO_THRESHOLD) {}

size_t AutoThreshold::getSize() { return COMMAND_SIZE; }

ReturnValue_t AutoThreshold::createCommand(uint8_t* buffer) {
  sif::debug << "creating auto threshold command" << std::endl;
  ReturnValue_t result = returnvalue::OK;
  uint8_t offset = 0;
  std::string param;
  addSetParamHeader(buffer, startracker::ID::LOG_SUBSCRIPTION);
  offset = 2;
  result = getParam(arcseckeys::AT_MODE, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += 1;
  result = getParam(arcseckeys::AT_DESIRED_BLOB_COUNTS, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint8(param, buffer + offset);
  offset += 1;
  result = getParam(arcseckeys::AT_MIN_THRESHOLD, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint16(param, buffer + offset);
  offset += 2;
  result = getParam(arcseckeys::AT_MAX_THRESHOLD, param);
  if (result != returnvalue::OK) {
    return result;
  }
  adduint16(param, buffer + offset);
  offset += 2;
  result = getParam(arcseckeys::AT_THRESHOLD_KP, param);
  if (result != returnvalue::OK) {
    return result;
  }
  addfloat(param, buffer + offset);
  return returnvalue::OK;
}