YouBotJointParameterPasswordProtected.cpp

Go to the documentation of this file.

/****************************************************************
 *
 * Copyright (c) 2011
 * All rights reserved.
 *
 * Hochschule Bonn-Rhein-Sieg
 * University of Applied Sciences
 * Computer Science Department
 *
 * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 *
 * Author:
 * Jan Paulus, Nico Hochgeschwender, Michael Reckhaus, Azamat Shakhimardanov
 * Supervised by:
 * Gerhard K. Kraetzschmar
 *
 * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 *
 * This sofware is published under a dual-license: GNU Lesser General Public 
 * License LGPL 2.1 and BSD license. The dual-license implies that users of this
 * code may choose which terms they prefer.
 *
 * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * 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.
 *     * Neither the name of the Hochschule Bonn-Rhein-Sieg nor the names of its
 *       contributors may be used to endorse or promote products derived from
 *       this software without specific prior written permission.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License LGPL as
 * published by the Free Software Foundation, either version 2.1 of the
 * License, or (at your option) any later version or the BSD license.
 *
 * 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 Lesser General Public License LGPL and the BSD license for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License LGPL and BSD license along with this program.
 *
 ****************************************************************/
#include <youbot_driver/youbot/YouBotJointParameterPasswordProtected.hpp>
namespace youbot
{

YouBotJointParameterPasswordProtected::YouBotJointParameterPasswordProtected()
{
  // Bouml preserved body begin 000A4CF1
  // Bouml preserved body end 000A4CF1
}

YouBotJointParameterPasswordProtected::~YouBotJointParameterPasswordProtected()
{
  // Bouml preserved body begin 000A4D71
  // Bouml preserved body end 000A4D71
}

ActivateOvervoltageProtection::ActivateOvervoltageProtection()
{
  // Bouml preserved body begin 00083371
  this->name = "ActivateOvervoltageProtection";
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 00083371
}

ActivateOvervoltageProtection::~ActivateOvervoltageProtection()
{
  // Bouml preserved body begin 000833F1
  // Bouml preserved body end 000833F1
}

void ActivateOvervoltageProtection::getParameter(bool& parameter) const
{
  // Bouml preserved body begin 00083471
  parameter = this->value;
  // Bouml preserved body end 00083471
}

void ActivateOvervoltageProtection::setParameter(const bool parameter)
{
  // Bouml preserved body begin 000834F1
  this->value = parameter;
  // Bouml preserved body end 000834F1
}

void ActivateOvervoltageProtection::toString(std::string& value)
{
  // Bouml preserved body begin 0009E4F1
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 0009E4F1
}

void ActivateOvervoltageProtection::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                                        const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 00083571

  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 245; //ActivateOvervoltageProtection
  message.stctOutput.value = value;

  // Bouml preserved body end 00083571
}

void ActivateOvervoltageProtection::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message,
                                                        const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 000835F1
  this->value = message.stctInput.value;
  // Bouml preserved body end 000835F1
}

ActualCommutationOffset::ActualCommutationOffset()
{
  // Bouml preserved body begin 0007D871
  this->name = "ActualCommutationOffset";
  this->lowerLimit = INT_MIN;
  this->upperLimit = INT_MAX;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 0007D871
}

ActualCommutationOffset::~ActualCommutationOffset()
{
  // Bouml preserved body begin 0007D8F1
  // Bouml preserved body end 0007D8F1
}

void ActualCommutationOffset::getParameter(int& parameter) const
{
  // Bouml preserved body begin 0007D971
  parameter = this->value;
  // Bouml preserved body end 0007D971
}

void ActualCommutationOffset::setParameter(const int parameter)
{
  // Bouml preserved body begin 0007D9F1
  if (this->lowerLimit > parameter)
  {
    throw std::out_of_range("The parameter exceeds the lower limit");
  }
  if (this->upperLimit < parameter)
  {
    throw std::out_of_range("The parameter exceeds the upper limit");
  }

  this->value = parameter;
  // Bouml preserved body end 0007D9F1
}

void ActualCommutationOffset::toString(std::string& value)
{
  // Bouml preserved body begin 0009D771
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 0009D771
}

void ActualCommutationOffset::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                                  const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 0007DA71

  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 165; //ActualCommutationOffset
  message.stctOutput.value = value;

  // Bouml preserved body end 0007DA71
}

void ActualCommutationOffset::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message,
                                                  const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 0007DAF1
  this->value = (int32)message.stctInput.value;
  // Bouml preserved body end 0007DAF1
}

ApproveProtectedParameters::ApproveProtectedParameters()
{
  // Bouml preserved body begin 000956F1
  this->name = "ApproveProtectedParameters";
  this->lowerLimit = INT_MIN;
  this->upperLimit = INT_MAX;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 000956F1
}

ApproveProtectedParameters::~ApproveProtectedParameters()
{
  // Bouml preserved body begin 00095771
  // Bouml preserved body end 00095771
}

void ApproveProtectedParameters::getParameter(int& parameter) const
{
  // Bouml preserved body begin 000957F1
  parameter = this->value;
  // Bouml preserved body end 000957F1
}

void ApproveProtectedParameters::setParameter(const int parameter)
{
  // Bouml preserved body begin 00095871
  if (this->lowerLimit > parameter)
  {
    throw std::out_of_range("The parameter exceeds the lower limit");
  }
  if (this->upperLimit < parameter)
  {
    throw std::out_of_range("The parameter exceeds the upper limit");
  }
  this->value = parameter;
  // Bouml preserved body end 00095871
}

void ApproveProtectedParameters::toString(std::string& value)
{
  // Bouml preserved body begin 0009E671
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 0009E671
}

void ApproveProtectedParameters::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                                     const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 000958F1
  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 248; //ApproveProtectedParameters
  message.stctOutput.value = value;
  // Bouml preserved body end 000958F1
}

void ApproveProtectedParameters::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message,
                                                     const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 00095971
  if (message.stctOutput.commandNumber == message.stctInput.commandNumber && message.stctInput.status == NO_ERROR)
  {
    this->value = message.stctInput.value;
  }
  // Bouml preserved body end 00095971
}

BEMFConstant::BEMFConstant()
{
  // Bouml preserved body begin 00082B71
  this->name = "BEMFConstant";
  this->lowerLimit = INT_MIN;
  this->upperLimit = INT_MAX;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 00082B71
}

BEMFConstant::~BEMFConstant()
{
  // Bouml preserved body begin 00082BF1
  // Bouml preserved body end 00082BF1
}

void BEMFConstant::getParameter(int& parameter) const
{
  // Bouml preserved body begin 00082C71
  parameter = this->value;
  // Bouml preserved body end 00082C71
}

void BEMFConstant::setParameter(const int parameter)
{
  // Bouml preserved body begin 00082CF1
  if (this->lowerLimit > parameter)
  {
    throw std::out_of_range("The parameter exceeds the lower limit");
  }
  if (this->upperLimit < parameter)
  {
    throw std::out_of_range("The parameter exceeds the upper limit");
  }

  this->value = parameter;
  // Bouml preserved body end 00082CF1
}

void BEMFConstant::toString(std::string& value)
{
  // Bouml preserved body begin 0009E1F1
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 0009E1F1
}

void BEMFConstant::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                       const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 00082D71

  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 239; //BEMFConstant
  message.stctOutput.value = value; //TODO do convertion

  // Bouml preserved body end 00082D71
}

void BEMFConstant::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message, const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 00082DF1
  this->value = (int32)message.stctInput.value; //TODO do convertion
  // Bouml preserved body end 00082DF1
}

CommutationMode::CommutationMode()
{
  // Bouml preserved body begin 000704F1
  this->name = "CommutationMode";
  this->lowerLimit = 0;
  this->upperLimit = 5;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 000704F1
}

CommutationMode::~CommutationMode()
{
  // Bouml preserved body begin 00070571
  // Bouml preserved body end 00070571
}

void CommutationMode::getParameter(unsigned int& parameter) const
{
  // Bouml preserved body begin 000705F1
  parameter = this->value;
  // Bouml preserved body end 000705F1
}

void CommutationMode::setParameter(const unsigned int parameter)
{
  // Bouml preserved body begin 00093471
  if (this->lowerLimit > parameter)
  {
    throw std::out_of_range("The parameter exceeds the lower limit");
  }
  if (this->upperLimit < parameter)
  {
    throw std::out_of_range("The parameter exceeds the upper limit");
  }
  this->value = parameter;
  // Bouml preserved body end 00093471
}

void CommutationMode::toString(std::string& value)
{
  // Bouml preserved body begin 0009E7F1
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 0009E7F1
}

void CommutationMode::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                          const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 00070671
  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 159; //CommutationMode
  message.stctOutput.value = value;
  // Bouml preserved body end 00070671
}

void CommutationMode::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message, const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 000720F1
  if (message.stctOutput.commandNumber == message.stctInput.commandNumber && message.stctInput.status == NO_ERROR)
  {
    this->value = message.stctInput.value; //TODO do convertion
  }
  // Bouml preserved body end 000720F1
}

CommutationMotorCurrent::CommutationMotorCurrent()
{
  // Bouml preserved body begin 0008C371
  this->name = "CommutationMotorCurrent";
  this->lowerLimit = 0 * ampere;
  this->upperLimit = INT_MAX * ampere;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 0008C371
}

CommutationMotorCurrent::~CommutationMotorCurrent()
{
  // Bouml preserved body begin 0008C3F1
  // Bouml preserved body end 0008C3F1
}

void CommutationMotorCurrent::getParameter(quantity<current>& parameter) const
{
  // Bouml preserved body begin 0008C471
  parameter = this->value;
  // Bouml preserved body end 0008C471
}

void CommutationMotorCurrent::setParameter(const quantity<current>& parameter)
{
  // Bouml preserved body begin 0008C4F1
  if (this->lowerLimit > parameter)
  {
    throw std::out_of_range("The parameter exceeds the lower limit");
  }
  if (this->upperLimit < parameter)
  {
    throw std::out_of_range("The parameter exceeds the upper limit");
  }

  this->value = parameter;
  // Bouml preserved body end 0008C4F1
}

void CommutationMotorCurrent::toString(std::string& value)
{
  // Bouml preserved body begin 0009DCF1
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 0009DCF1
}

void CommutationMotorCurrent::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                                  const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 0008C571

  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 177; //CommutationMotorCurrent
  message.stctOutput.value = (uint32)(value.value() * 1000.0); // ampere to milli ampere

  // Bouml preserved body end 0008C571
}

void CommutationMotorCurrent::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message,
                                                  const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 0008C5F1
  double temp = (uint32)message.stctInput.value;
  this->value = temp / 1000.0 * ampere; //milli ampere to ampere
  // Bouml preserved body end 0008C5F1
}

CurrentControlLoopDelay::CurrentControlLoopDelay()
{
  // Bouml preserved body begin 00079F71
  this->name = "CurrentControlLoopDelay";
  this->lowerLimit = 0;
  this->upperLimit = INT_MAX * seconds;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 00079F71
}

CurrentControlLoopDelay::~CurrentControlLoopDelay()
{
  // Bouml preserved body begin 00079FF1
  // Bouml preserved body end 00079FF1
}

void CurrentControlLoopDelay::getParameter(quantity<si::time>& parameter) const
{
  // Bouml preserved body begin 0007A071
  parameter = this->value;
  // Bouml preserved body end 0007A071
}

void CurrentControlLoopDelay::setParameter(const quantity<si::time>& parameter)
{
  // Bouml preserved body begin 0007A0F1
  if (this->lowerLimit > parameter)
  {
    throw std::out_of_range("The parameter exceeds the lower limit");
  }
  if (this->upperLimit < parameter)
  {
    throw std::out_of_range("The parameter exceeds the upper limit");
  }

  this->value = parameter;
  // Bouml preserved body end 0007A0F1
}

void CurrentControlLoopDelay::toString(std::string& value)
{
  // Bouml preserved body begin 0009CFF1
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 0009CFF1
}

void CurrentControlLoopDelay::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                                  const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 0007A171

  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 134; //CurrentControlLoopDelay
  message.stctOutput.value = (uint32)(value.value() * 1000 * 1000 / 50.0); //sec to µsec

  // Bouml preserved body end 0007A171
}

void CurrentControlLoopDelay::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message,
                                                  const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 0007A1F1
  double temp = (uint32)message.stctInput.value;
  this->value = (temp / (1000.0 * 1000.0)) * 50 * seconds; //µsec to sec
  // Bouml preserved body end 0007A1F1
}

EncoderResolution::EncoderResolution()
{
  // Bouml preserved body begin 000713F1
  this->name = "EncoderResolution";
  this->lowerLimit = 0;
  this->upperLimit = INT_MAX;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 000713F1
}

EncoderResolution::~EncoderResolution()
{
  // Bouml preserved body begin 00071471
  // Bouml preserved body end 00071471
}

void EncoderResolution::getParameter(unsigned int& parameter) const
{
  // Bouml preserved body begin 000714F1
  parameter = this->value;
  // Bouml preserved body end 000714F1
}

void EncoderResolution::setParameter(const unsigned int parameter)
{
  // Bouml preserved body begin 00093671
  if (this->lowerLimit > parameter)
  {
    throw std::out_of_range("The parameter exceeds the lower limit");
  }
  if (this->upperLimit < parameter)
  {
    throw std::out_of_range("The parameter exceeds the upper limit");
  }
  this->value = parameter;
  // Bouml preserved body end 00093671
}

void EncoderResolution::toString(std::string& value)
{
  // Bouml preserved body begin 0009E9F1
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 0009E9F1
}

void EncoderResolution::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                            const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 00071571
  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 250; //EncoderResolution
  message.stctOutput.value = (uint32)value;
  // Bouml preserved body end 00071571
}

void EncoderResolution::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message, const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 00072371
  if (message.stctOutput.commandNumber == message.stctInput.commandNumber && message.stctInput.status == NO_ERROR)
  {
    this->value = (uint32)message.stctInput.value;
  }
  // Bouml preserved body end 00072371
}

EncoderStopSwitch::EncoderStopSwitch()
{
  // Bouml preserved body begin 0007D471
  this->name = "EncoderStopSwitch";
  this->lowerLimit = 0;
  this->upperLimit = 3;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 0007D471
}

EncoderStopSwitch::~EncoderStopSwitch()
{
  // Bouml preserved body begin 0007D4F1
  // Bouml preserved body end 0007D4F1
}

void EncoderStopSwitch::getParameter(unsigned int& parameter) const
{
  // Bouml preserved body begin 0007D571
  parameter = this->value;
  // Bouml preserved body end 0007D571
}

void EncoderStopSwitch::setParameter(const unsigned int parameter)
{
  // Bouml preserved body begin 0007D5F1
  if (this->lowerLimit > parameter)
  {
    throw std::out_of_range("The parameter exceeds the lower limit");
  }
  if (this->upperLimit < parameter)
  {
    throw std::out_of_range("The parameter exceeds the upper limit");
  }

  this->value = parameter;
  // Bouml preserved body end 0007D5F1
}

void EncoderStopSwitch::toString(std::string& value)
{
  // Bouml preserved body begin 0009D6F1
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 0009D6F1
}

void EncoderStopSwitch::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                            const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 0007D671

  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 164; //EncoderStopSwitch
  message.stctOutput.value = (uint32)value;

  // Bouml preserved body end 0007D671
}

void EncoderStopSwitch::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message, const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 0007D6F1
  this->value = (uint32)message.stctInput.value;
  // Bouml preserved body end 0007D6F1
}

HallSensorPolarityReversal::HallSensorPolarityReversal()
{
  // Bouml preserved body begin 00071CF1
  this->name = "HallSensorPolarityReversal";
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 00071CF1
}

HallSensorPolarityReversal::~HallSensorPolarityReversal()
{
  // Bouml preserved body begin 00071D71
  // Bouml preserved body end 00071D71
}

void HallSensorPolarityReversal::getParameter(bool& parameter) const
{
  // Bouml preserved body begin 00071DF1
  parameter = this->value;
  // Bouml preserved body end 00071DF1
}

void HallSensorPolarityReversal::setParameter(const bool parameter)
{
  // Bouml preserved body begin 00093771
  this->value = parameter;
  // Bouml preserved body end 00093771
}

void HallSensorPolarityReversal::toString(std::string& value)
{
  // Bouml preserved body begin 0009EAF1
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 0009EAF1
}

void HallSensorPolarityReversal::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                                     const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 00071E71
  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 254; //HallSensorPolarityReversal
  message.stctOutput.value = (uint32)value;
  // Bouml preserved body end 00071E71
}

void HallSensorPolarityReversal::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message,
                                                     const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 000724F1
  if (message.stctOutput.commandNumber == message.stctInput.commandNumber && message.stctInput.status == NO_ERROR)
  {
    this->value = (uint32)message.stctInput.value;
  }
  // Bouml preserved body end 000724F1
}

I2tExceedCounter::I2tExceedCounter()
{
  // Bouml preserved body begin 000A1171
  this->name = "I2tExceedCounter";
  this->lowerLimit = 0;
  this->upperLimit = INT_MAX;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 000A1171
}

I2tExceedCounter::~I2tExceedCounter()
{
  // Bouml preserved body begin 000A11F1
  // Bouml preserved body end 000A11F1
}

void I2tExceedCounter::getParameter(unsigned int& parameter) const
{
  // Bouml preserved body begin 000A1271
  parameter = this->value;
  // Bouml preserved body end 000A1271
}

void I2tExceedCounter::setParameter(const unsigned int parameter)
{
  // Bouml preserved body begin 000A12F1
  if (this->lowerLimit > parameter)
  {
    throw std::out_of_range("The parameter exceeds the lower limit");
  }
  if (this->upperLimit < parameter)
  {
    throw std::out_of_range("The parameter exceeds the upper limit");
  }
  this->value = parameter;
  // Bouml preserved body end 000A12F1
}

void I2tExceedCounter::toString(std::string& value)
{
  // Bouml preserved body begin 000A1371
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 000A1371
}

void I2tExceedCounter::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                           const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 000A13F1
  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 28; //I2tExceedCounter
  message.stctOutput.value = (uint32)value;
  // Bouml preserved body end 000A13F1
}

void I2tExceedCounter::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message, const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 000A1471
  if (message.stctOutput.commandNumber == message.stctInput.commandNumber && message.stctInput.status == NO_ERROR)
  {
    this->value = (uint32)message.stctInput.value;
  }
  // Bouml preserved body end 000A1471
}

I2tLimit::I2tLimit()
{
  // Bouml preserved body begin 000A0871
  this->name = "I2tLimit";
  this->lowerLimit = 0;
  this->upperLimit = INT_MAX;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 000A0871
}

I2tLimit::~I2tLimit()
{
  // Bouml preserved body begin 000A08F1
  // Bouml preserved body end 000A08F1
}

void I2tLimit::getParameter(unsigned int& parameter) const
{
  // Bouml preserved body begin 000A0971
  parameter = this->value;
  // Bouml preserved body end 000A0971
}

void I2tLimit::setParameter(const unsigned int parameter)
{
  // Bouml preserved body begin 000A09F1
  if (this->lowerLimit > parameter)
  {
    throw std::out_of_range("The parameter exceeds the lower limit");
  }
  if (this->upperLimit < parameter)
  {
    throw std::out_of_range("The parameter exceeds the upper limit");
  }
  this->value = parameter;
  // Bouml preserved body end 000A09F1
}

void I2tLimit::toString(std::string& value)
{
  // Bouml preserved body begin 000A0A71
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 000A0A71
}

void I2tLimit::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                   const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 000A0AF1
  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 26; //I2tLimit
  message.stctOutput.value = (uint32)value;
  // Bouml preserved body end 000A0AF1
}

void I2tLimit::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message, const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 000A0B71
  if (message.stctOutput.commandNumber == message.stctInput.commandNumber && message.stctInput.status == NO_ERROR)
  {
    this->value = (uint32)message.stctInput.value;
  }
  // Bouml preserved body end 000A0B71
}

InitializationMode::InitializationMode()
{
  // Bouml preserved body begin 000710F1
  this->name = "InitializationMode";
  this->lowerLimit = 0;
  this->upperLimit = 2;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 000710F1
}

InitializationMode::~InitializationMode()
{
  // Bouml preserved body begin 00071171
  // Bouml preserved body end 00071171
}

void InitializationMode::getParameter(int& parameter) const
{
  // Bouml preserved body begin 000711F1
  parameter = this->value;
  // Bouml preserved body end 000711F1
}

void InitializationMode::setParameter(const int parameter)
{
  // Bouml preserved body begin 000935F1
  if (this->lowerLimit > parameter)
  {
    throw std::out_of_range("The parameter exceeds the lower limit");
  }
  if (this->upperLimit < parameter)
  {
    throw std::out_of_range("The parameter exceeds the upper limit");
  }
  this->value = parameter;
  // Bouml preserved body end 000935F1
}

void InitializationMode::toString(std::string& value)
{
  // Bouml preserved body begin 0009E971
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 0009E971
}

void InitializationMode::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                             const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 00071271
  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 249; //InitializationMode
  message.stctOutput.value = value;
  // Bouml preserved body end 00071271
}

void InitializationMode::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message, const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 000722F1
  if (message.stctOutput.commandNumber == message.stctInput.commandNumber && message.stctInput.status == NO_ERROR)
  {
    this->value = (int32)message.stctInput.value;
  }
  // Bouml preserved body end 000722F1
}

InitSineDelay::InitSineDelay()
{
  // Bouml preserved body begin 00082F71
  this->name = "InitSineDelay";
  this->lowerLimit = -32.768 * seconds;
  this->upperLimit = +32.767 * seconds;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 00082F71
}

InitSineDelay::~InitSineDelay()
{
  // Bouml preserved body begin 00082FF1
  // Bouml preserved body end 00082FF1
}

void InitSineDelay::getParameter(quantity<si::time>& parameter) const
{
  // Bouml preserved body begin 00083071
  parameter = this->value;
  // Bouml preserved body end 00083071
}

void InitSineDelay::setParameter(const quantity<si::time>& parameter)
{
  // Bouml preserved body begin 000830F1
  if (this->lowerLimit > parameter)
  {
    throw std::out_of_range("The parameter exceeds the lower limit");
  }
  if (this->upperLimit < parameter)
  {
    throw std::out_of_range("The parameter exceeds the upper limit");
  }

  this->value = parameter;
  // Bouml preserved body end 000830F1
}

void InitSineDelay::toString(std::string& value)
{
  // Bouml preserved body begin 0009E3F1
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 0009E3F1
}

void InitSineDelay::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                        const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 00083171

  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 244; //InitSineDelay
  message.stctOutput.value = (int32)(value.value() * 1000); //sec to µsec

  // Bouml preserved body end 00083171
}

void InitSineDelay::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message, const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 000831F1
  double temp = (int32)message.stctInput.value;
  this->value = (temp / 1000.0) * seconds; //µsec to sec
  // Bouml preserved body end 000831F1
}

MassInertiaConstant::MassInertiaConstant()
{
  // Bouml preserved body begin 00082771
  this->name = "MassInertiaConstant";
  this->lowerLimit = INT_MIN;
  this->upperLimit = INT_MAX;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 00082771
}

MassInertiaConstant::~MassInertiaConstant()
{
  // Bouml preserved body begin 000827F1
  // Bouml preserved body end 000827F1
}

void MassInertiaConstant::getParameter(int& parameter) const
{
  // Bouml preserved body begin 00082871
  parameter = this->value;
  // Bouml preserved body end 00082871
}

void MassInertiaConstant::setParameter(const int parameter)
{
  // Bouml preserved body begin 000828F1
  if (this->lowerLimit > parameter)
  {
    throw std::out_of_range("The parameter exceeds the lower limit");
  }
  if (this->upperLimit < parameter)
  {
    throw std::out_of_range("The parameter exceeds the upper limit");
  }

  this->value = parameter;
  // Bouml preserved body end 000828F1
}

void MassInertiaConstant::toString(std::string& value)
{
  // Bouml preserved body begin 0009E171
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 0009E171
}

void MassInertiaConstant::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                              const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 00082971

  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 238; //MassInertiaConstant
  message.stctOutput.value = (int32)value; //TODO do convertion

  // Bouml preserved body end 00082971
}

void MassInertiaConstant::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message, const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 000829F1
  this->value = (int32)message.stctInput.value; //TODO do convertion
  // Bouml preserved body end 000829F1
}

MaximumMotorCurrent::MaximumMotorCurrent()
{
  // Bouml preserved body begin 0006A5F1
  this->name = "MaximumMotorCurrent";
  this->lowerLimit = 0 * ampere;
  this->upperLimit = INT_MAX * ampere;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 0006A5F1
}

MaximumMotorCurrent::~MaximumMotorCurrent()
{
  // Bouml preserved body begin 0006A671
  // Bouml preserved body end 0006A671
}

void MaximumMotorCurrent::getParameter(quantity<current>& parameter) const
{
  // Bouml preserved body begin 0006A6F1
  parameter = this->value;
  // Bouml preserved body end 0006A6F1
}

void MaximumMotorCurrent::setParameter(const quantity<current>& parameter)
{
  // Bouml preserved body begin 0006A771
  if (this->lowerLimit > parameter)
  {
    throw std::out_of_range("The parameter exceeds the lower limit");
  }
  if (this->upperLimit < parameter)
  {
    throw std::out_of_range("The parameter exceeds the upper limit");
  }

  this->value = parameter;
  // Bouml preserved body end 0006A771
}

void MaximumMotorCurrent::toString(std::string& value)
{
  // Bouml preserved body begin 0009CA71
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 0009CA71
}

void MaximumMotorCurrent::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                              const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 0006A7F1

  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 6; //MaximumMotorCurrent
  message.stctOutput.value = (uint32)(value.value() * 1000.0); // ampere to milli ampere

  // Bouml preserved body end 0006A7F1
}

void MaximumMotorCurrent::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message, const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 0006A871
  double temp = (uint32)message.stctInput.value;
  this->value = temp / 1000.0 * ampere; //milli ampere to ampere
  // Bouml preserved body end 0006A871
}

MotorCoilResistance::MotorCoilResistance()
{
  // Bouml preserved body begin 00070DF1
  this->name = "MotorCoilResistance";
  this->lowerLimit = INT_MIN * ohm;
  this->upperLimit = INT_MAX * ohm;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 00070DF1
}

MotorCoilResistance::~MotorCoilResistance()
{
  // Bouml preserved body begin 00070E71
  // Bouml preserved body end 00070E71
}

void MotorCoilResistance::getParameter(quantity<resistance>& parameter) const
{
  // Bouml preserved body begin 00070EF1
  parameter = this->value;
  // Bouml preserved body end 00070EF1
}

void MotorCoilResistance::setParameter(const quantity<resistance>& parameter)
{
  // Bouml preserved body begin 00093571
  if (this->lowerLimit > parameter)
  {
    throw std::out_of_range("The parameter exceeds the lower limit");
  }
  if (this->upperLimit < parameter)
  {
    throw std::out_of_range("The parameter exceeds the upper limit");
  }
  this->value = parameter;
  // Bouml preserved body end 00093571
}

void MotorCoilResistance::toString(std::string& value)
{
  // Bouml preserved body begin 0009E8F1
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 0009E8F1
}

void MotorCoilResistance::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                              const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 00070F71
  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 240; //MotorCoilResistance
  message.stctOutput.value = (int32)(value.value() * 1000); //from ohm to milli ohm
  // Bouml preserved body end 00070F71
}

void MotorCoilResistance::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message, const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 00072271
  if (message.stctOutput.commandNumber == message.stctInput.commandNumber && message.stctInput.status == NO_ERROR)
  {
    double temp = (int32)message.stctInput.value;
    this->value = temp / 1000.0 * ohm;
  }
  // Bouml preserved body end 00072271
}

MotorControllerTimeout::MotorControllerTimeout()
{
  // Bouml preserved body begin 0009F671
  this->name = "MotorControllerTimeout";
  this->lowerLimit = 0;
  this->upperLimit = INT_MAX * seconds;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 0009F671
}

MotorControllerTimeout::~MotorControllerTimeout()
{
  // Bouml preserved body begin 0009F6F1
  // Bouml preserved body end 0009F6F1
}

void MotorControllerTimeout::getParameter(quantity<si::time>& parameter) const
{
  // Bouml preserved body begin 0009F771
  parameter = this->value;
  // Bouml preserved body end 0009F771
}

void MotorControllerTimeout::setParameter(const quantity<si::time>& parameter)
{
  // Bouml preserved body begin 0009F7F1
  if (this->lowerLimit > parameter)
  {
    throw std::out_of_range("The parameter exceeds the lower limit");
  }
  if (this->upperLimit < parameter)
  {
    throw std::out_of_range("The parameter exceeds the upper limit");
  }

  this->value = parameter;
  // Bouml preserved body end 0009F7F1
}

void MotorControllerTimeout::toString(std::string& value)
{
  // Bouml preserved body begin 0009F871
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 0009F871
}

void MotorControllerTimeout::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                                 const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 0009F8F1

  if (msgType == SAP)
  {
    message.stctOutput.commandNumber = SGP;
  }
  else if (msgType == GAP)
  {
    message.stctOutput.commandNumber = GGP;
  }
  else
  {
    message.stctOutput.commandNumber = msgType;
  }
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 90; //MotorControllerTimeout
  message.stctOutput.value = value.value() * 1000; //sec to milli sec

  // Bouml preserved body end 0009F8F1
}

void MotorControllerTimeout::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message,
                                                 const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 0009F971
  this->value = ((double)message.stctInput.value) / 1000.0 * seconds; //milli sec to sec
  // Bouml preserved body end 0009F971
}

MotorPoles::MotorPoles()
{
  // Bouml preserved body begin 000719F1
  this->name = "MotorPoles";
  this->lowerLimit = 2;
  this->upperLimit = 254;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 000719F1
}

MotorPoles::~MotorPoles()
{
  // Bouml preserved body begin 00071A71
  // Bouml preserved body end 00071A71
}

void MotorPoles::getParameter(unsigned int& parameter) const
{
  // Bouml preserved body begin 00071AF1
  parameter = this->value;
  // Bouml preserved body end 00071AF1
}

void MotorPoles::setParameter(const unsigned int parameter)
{
  // Bouml preserved body begin 000937F1
  if (this->lowerLimit > parameter)
  {
    throw std::out_of_range("The parameter exceeds the lower limit");
  }
  if (this->upperLimit < parameter)
  {
    throw std::out_of_range("The parameter exceeds the upper limit");
  }
  this->value = parameter;
  // Bouml preserved body end 000937F1
}

void MotorPoles::toString(std::string& value)
{
  // Bouml preserved body begin 0009EB71
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 0009EB71
}

void MotorPoles::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                     const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 00071B71
  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 253; //MotorPoles
  message.stctOutput.value = (uint32)value;
  // Bouml preserved body end 00071B71
}

void MotorPoles::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message, const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 00072471
  if (message.stctOutput.commandNumber == message.stctInput.commandNumber && message.stctInput.status == NO_ERROR)
  {
    this->value = (uint32)message.stctInput.value;
  }
  // Bouml preserved body end 00072471
}

OperationalTime::OperationalTime()
{
  // Bouml preserved body begin 000A03F1
  this->name = "OperationalTime";
  this->lowerLimit = 0;
  this->upperLimit = INT_MAX * seconds;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 000A03F1
}

OperationalTime::~OperationalTime()
{
  // Bouml preserved body begin 000A0471
  // Bouml preserved body end 000A0471
}

void OperationalTime::getParameter(quantity<si::time>& parameter) const
{
  // Bouml preserved body begin 000A04F1
  parameter = this->value;
  // Bouml preserved body end 000A04F1
}

void OperationalTime::setParameter(const quantity<si::time>& parameter)
{
  // Bouml preserved body begin 000A0571
  if (this->lowerLimit > parameter)
  {
    throw std::out_of_range("The parameter exceeds the lower limit");
  }
  if (this->upperLimit < parameter)
  {
    throw std::out_of_range("The parameter exceeds the upper limit");
  }

  this->value = parameter;
  // Bouml preserved body end 000A0571
}

void OperationalTime::toString(std::string& value)
{
  // Bouml preserved body begin 000A05F1
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 000A05F1
}

void OperationalTime::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                          const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 000A0671
  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 30; //OperationalTime
  message.stctOutput.value = value.value() / 60.0; //sec to min

  // Bouml preserved body end 000A0671
}

void OperationalTime::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message, const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 000A06F1
  this->value = ((double)message.stctInput.value) * 60.0 * seconds; //min to sec
  // Bouml preserved body end 000A06F1
}

PIDControlTime::PIDControlTime()
{
  // Bouml preserved body begin 0006ADF1
  this->name = "PIDControlTime";
  this->lowerLimit = 0;
  this->upperLimit = INT_MAX * seconds;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 0006ADF1
}

PIDControlTime::~PIDControlTime()
{
  // Bouml preserved body begin 0006AE71
  // Bouml preserved body end 0006AE71
}

void PIDControlTime::getParameter(quantity<si::time>& parameter) const
{
  // Bouml preserved body begin 0006AEF1
  parameter = this->value;
  // Bouml preserved body end 0006AEF1
}

void PIDControlTime::setParameter(const quantity<si::time>& parameter)
{
  // Bouml preserved body begin 0006AF71
  if (this->lowerLimit > parameter)
  {
    throw std::out_of_range("The parameter exceeds the lower limit");
  }
  if (this->upperLimit < parameter)
  {
    throw std::out_of_range("The parameter exceeds the upper limit");
  }

  this->value = parameter;
  // Bouml preserved body end 0006AF71
}

void PIDControlTime::toString(std::string& value)
{
  // Bouml preserved body begin 0009CF71
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 0009CF71
}

void PIDControlTime::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                         const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 0006AFF1

  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 133; //PIDControlTime
  message.stctOutput.value = value.value() * 1000; //sec to milli sec

  // Bouml preserved body end 0006AFF1
}

void PIDControlTime::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message, const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 0006B071
  this->value = ((double)message.stctInput.value) / 1000 * seconds; //milli sec to sec
  // Bouml preserved body end 0006B071
}

ReversingEncoderDirection::ReversingEncoderDirection()
{
  // Bouml preserved body begin 000716F1
  this->name = "ReversingEncoderDirection";
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 000716F1
}

ReversingEncoderDirection::~ReversingEncoderDirection()
{
  // Bouml preserved body begin 00071771
  // Bouml preserved body end 00071771
}

bool ReversingEncoderDirection::getParameter(bool& parameter) const
{
  // Bouml preserved body begin 000717F1
  parameter = this->value;
  return this->value;
  // Bouml preserved body end 000717F1
}

void ReversingEncoderDirection::setParameter(const bool parameter)
{
  // Bouml preserved body begin 000936F1
  this->value = parameter;
  // Bouml preserved body end 000936F1
}

void ReversingEncoderDirection::toString(std::string& value)
{
  // Bouml preserved body begin 0009EA71
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 0009EA71
}

void ReversingEncoderDirection::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                                    const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 00071871
  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 251; //ReversingEncoderDirection
  message.stctOutput.value = value;
  // Bouml preserved body end 00071871
}

void ReversingEncoderDirection::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message,
                                                    const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 000723F1
  if (message.stctOutput.commandNumber == message.stctInput.commandNumber && message.stctInput.status == NO_ERROR)
  {
    this->value = message.stctInput.value;
  }
  // Bouml preserved body end 000723F1
}

SetEncoderCounterZeroAtNextNChannel::SetEncoderCounterZeroAtNextNChannel()
{
  // Bouml preserved body begin 0007C871
  this->name = "SetEncoderCounterZeroAtNextNChannel";
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 0007C871
}

SetEncoderCounterZeroAtNextNChannel::~SetEncoderCounterZeroAtNextNChannel()
{
  // Bouml preserved body begin 0007C8F1
  // Bouml preserved body end 0007C8F1
}

void SetEncoderCounterZeroAtNextNChannel::getParameter(bool& parameter) const
{
  // Bouml preserved body begin 0007C971
  parameter = this->value;
  // Bouml preserved body end 0007C971
}

void SetEncoderCounterZeroAtNextNChannel::setParameter(const bool parameter)
{
  // Bouml preserved body begin 0007C9F1
  this->value = parameter;
  // Bouml preserved body end 0007C9F1
}

void SetEncoderCounterZeroAtNextNChannel::toString(std::string& value)
{
  // Bouml preserved body begin 0009D571
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 0009D571
}

void SetEncoderCounterZeroAtNextNChannel::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                                              const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 0007CA71

  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 161; //SetEncoderCounterZeroAtNextNChannel
  message.stctOutput.value = value;

  // Bouml preserved body end 0007CA71
}

void SetEncoderCounterZeroAtNextNChannel::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message,
                                                              const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 0007CAF1
  this->value = message.stctInput.value;
  // Bouml preserved body end 0007CAF1
}

SetEncoderCounterZeroAtNextSwitch::SetEncoderCounterZeroAtNextSwitch()
{
  // Bouml preserved body begin 0007CC71
  this->name = "SetEncoderCounterZeroAtNextSwitch";
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 0007CC71
}

SetEncoderCounterZeroAtNextSwitch::~SetEncoderCounterZeroAtNextSwitch()
{
  // Bouml preserved body begin 0007CCF1
  // Bouml preserved body end 0007CCF1
}

void SetEncoderCounterZeroAtNextSwitch::getParameter(bool& parameter) const
{
  // Bouml preserved body begin 0007CD71
  parameter = this->value;
  // Bouml preserved body end 0007CD71
}

void SetEncoderCounterZeroAtNextSwitch::setParameter(const bool parameter)
{
  // Bouml preserved body begin 0007CDF1
  this->value = parameter;
  // Bouml preserved body end 0007CDF1
}

void SetEncoderCounterZeroAtNextSwitch::toString(std::string& value)
{
  // Bouml preserved body begin 0009D5F1
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 0009D5F1
}

void SetEncoderCounterZeroAtNextSwitch::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                                            const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 0007CE71

  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 162; //SetEncoderCounterZeroAtNextSwitch
  message.stctOutput.value = value;

  // Bouml preserved body end 0007CE71
}

void SetEncoderCounterZeroAtNextSwitch::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message,
                                                            const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 0007CEF1
  this->value = message.stctInput.value;
  // Bouml preserved body end 0007CEF1
}

SetEncoderCounterZeroOnlyOnce::SetEncoderCounterZeroOnlyOnce()
{
  // Bouml preserved body begin 0007D071
  this->name = "SetEncoderCounterZeroOnlyOnce";
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 0007D071
}

SetEncoderCounterZeroOnlyOnce::~SetEncoderCounterZeroOnlyOnce()
{
  // Bouml preserved body begin 0007D0F1
  // Bouml preserved body end 0007D0F1
}

void SetEncoderCounterZeroOnlyOnce::getParameter(bool& parameter) const
{
  // Bouml preserved body begin 0007D171
  parameter = this->value;
  // Bouml preserved body end 0007D171
}

void SetEncoderCounterZeroOnlyOnce::setParameter(const bool parameter)
{
  // Bouml preserved body begin 0007D1F1
  this->value = parameter;
  // Bouml preserved body end 0007D1F1
}

void SetEncoderCounterZeroOnlyOnce::toString(std::string& value)
{
  // Bouml preserved body begin 0009D671
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 0009D671
}

void SetEncoderCounterZeroOnlyOnce::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                                        const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 0007D271

  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 163; //SetEncoderCounterZeroOnlyOnce
  message.stctOutput.value = value;

  // Bouml preserved body end 0007D271
}

void SetEncoderCounterZeroOnlyOnce::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message,
                                                        const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 0007D2F1
  this->value = message.stctInput.value;
  // Bouml preserved body end 0007D2F1
}

SineInitializationVelocity::SineInitializationVelocity()
{
  // Bouml preserved body begin 0006EDF1
  this->name = "SineInitializationVelocity";
  this->lowerLimit = INT_MIN;
  this->upperLimit = INT_MAX;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 0006EDF1
}

SineInitializationVelocity::~SineInitializationVelocity()
{
  // Bouml preserved body begin 0006EE71
  // Bouml preserved body end 0006EE71
}

void SineInitializationVelocity::getParameter(int& parameter) const
{
  // Bouml preserved body begin 0006EEF1
  parameter = this->value;
  // Bouml preserved body end 0006EEF1
}

void SineInitializationVelocity::setParameter(const int parameter)
{
  // Bouml preserved body begin 0006EF71
  if (this->lowerLimit > parameter)
  {
    throw std::out_of_range("The parameter exceeds the lower limit");
  }
  if (this->upperLimit < parameter)
  {
    throw std::out_of_range("The parameter exceeds the upper limit");
  }

  this->value = parameter;
  // Bouml preserved body end 0006EF71
}

void SineInitializationVelocity::toString(std::string& value)
{
  // Bouml preserved body begin 0009E271
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 0009E271
}

void SineInitializationVelocity::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                                     const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 0006EFF1

  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 241; //SineInitializationVelocity
  message.stctOutput.value = (int32)value;
  // Bouml preserved body end 0006EFF1
}

void SineInitializationVelocity::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message,
                                                     const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 0006F071
  this->value = (int32)message.stctInput.value;
  // Bouml preserved body end 0006F071
}

StopSwitchPolarity::StopSwitchPolarity()
{
  // Bouml preserved body begin 0007DC71
  this->name = "StopSwitchPolarity";
  this->lowerLimit = 0;
  this->upperLimit = 3;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 0007DC71
}

StopSwitchPolarity::~StopSwitchPolarity()
{
  // Bouml preserved body begin 0007DCF1
  // Bouml preserved body end 0007DCF1
}

void StopSwitchPolarity::getParameter(unsigned int& parameter) const
{
  // Bouml preserved body begin 0007DD71
  parameter = this->value;
  // Bouml preserved body end 0007DD71
}

void StopSwitchPolarity::setParameter(const unsigned int parameter)
{
  // Bouml preserved body begin 0007DDF1
  if (this->lowerLimit > parameter)
  {
    throw std::out_of_range("The parameter exceeds the lower limit");
  }
  if (this->upperLimit < parameter)
  {
    throw std::out_of_range("The parameter exceeds the upper limit");
  }

  this->value = parameter;
  // Bouml preserved body end 0007DDF1
}

void StopSwitchPolarity::toString(std::string& value)
{
  // Bouml preserved body begin 0009D7F1
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 0009D7F1
}

void StopSwitchPolarity::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                             const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 0007DE71

  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 166; //StopSwitchPolarity
  message.stctOutput.value = value;

  // Bouml preserved body end 0007DE71
}

void StopSwitchPolarity::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message, const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 0007DEF1
  this->value = message.stctInput.value;
  // Bouml preserved body end 0007DEF1
}

ThermalWindingTimeConstant::ThermalWindingTimeConstant()
{
  // Bouml preserved body begin 0009FF71
  this->name = "ThermalWindingTimeConstant";
  this->lowerLimit = 0;
  this->upperLimit = INT_MAX * seconds;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 0009FF71
}

ThermalWindingTimeConstant::~ThermalWindingTimeConstant()
{
  // Bouml preserved body begin 0009FFF1
  // Bouml preserved body end 0009FFF1
}

void ThermalWindingTimeConstant::getParameter(quantity<si::time>& parameter) const
{
  // Bouml preserved body begin 000A0071
  parameter = this->value;
  // Bouml preserved body end 000A0071
}

void ThermalWindingTimeConstant::setParameter(const quantity<si::time>& parameter)
{
  // Bouml preserved body begin 000A00F1
  if (this->lowerLimit > parameter)
  {
    throw std::out_of_range("The parameter exceeds the lower limit");
  }
  if (this->upperLimit < parameter)
  {
    throw std::out_of_range("The parameter exceeds the upper limit");
  }

  this->value = parameter;
  // Bouml preserved body end 000A00F1
}

void ThermalWindingTimeConstant::toString(std::string& value)
{
  // Bouml preserved body begin 000A0171
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 000A0171
}

void ThermalWindingTimeConstant::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                                     const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 000A01F1
  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 25; //ThermalWindingTimeConstant
  message.stctOutput.value = value.value() * 1000; //sec to milli sec

  // Bouml preserved body end 000A01F1
}

void ThermalWindingTimeConstant::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message,
                                                     const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 000A0271
  this->value = ((double)message.stctInput.value) / 1000.0 * seconds; //milli sec to sec
  // Bouml preserved body end 000A0271
}

MotorHaltedVelocity::MotorHaltedVelocity()
{
  // Bouml preserved body begin 000CB871
  this->name = "MotorHaltedVelocity";
  this->lowerLimit = INT_MIN;
  this->upperLimit = INT_MAX;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 000CB871
}

MotorHaltedVelocity::~MotorHaltedVelocity()
{
  // Bouml preserved body begin 000CB8F1
  // Bouml preserved body end 000CB8F1
}

void MotorHaltedVelocity::getParameter(int& parameter) const
{
  // Bouml preserved body begin 000CB971
  parameter = this->value;
  // Bouml preserved body end 000CB971
}

void MotorHaltedVelocity::setParameter(const int parameter)
{
  // Bouml preserved body begin 000CB9F1
  if (this->lowerLimit > parameter)
  {
    throw std::out_of_range("The parameter exceeds the lower limit");
  }
  if (this->upperLimit < parameter)
  {
    throw std::out_of_range("The parameter exceeds the upper limit");
  }

  this->value = parameter;
  // Bouml preserved body end 000CB9F1
}

void MotorHaltedVelocity::toString(std::string& value)
{
  // Bouml preserved body begin 000CBA71
  std::stringstream ss;
  ss << this->name << ": " << this->value;
  value = ss.str();
  // Bouml preserved body end 000CBA71
}

void MotorHaltedVelocity::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message, TMCLCommandNumber msgType,
                                              const YouBotJointStorage& storage) const
{
  // Bouml preserved body begin 000CBAF1

  message.stctOutput.commandNumber = msgType;
  message.stctOutput.moduleAddress = DRIVE;
  message.stctOutput.typeNumber = 9; //MotorHaltedVelocity
  message.stctOutput.value = (int32)value;
  // Bouml preserved body end 000CBAF1
}

void MotorHaltedVelocity::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message, const YouBotJointStorage& storage)
{
  // Bouml preserved body begin 000CBB71
  this->value = (int32)message.stctInput.value;
  // Bouml preserved body end 000CBB71
}

} // namespace youbot