YouBotGripperParameter.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/YouBotGripperParameter.hpp>
namespace youbot
{

YouBotGripperParameter::YouBotGripperParameter()
{
  // Bouml preserved body begin 0005F0F1
  // Bouml preserved body end 0005F0F1
}

YouBotGripperParameter::~YouBotGripperParameter()
{
  // Bouml preserved body begin 0005F171
  // Bouml preserved body end 0005F171
}

GripperFirmwareVersion::GripperFirmwareVersion()
{
  // Bouml preserved body begin 000BEAF1
  this->name = "FirmwareVersion";
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 000BEAF1
}

GripperFirmwareVersion::~GripperFirmwareVersion()
{
  // Bouml preserved body begin 000BEB71
  // Bouml preserved body end 000BEB71
}

void GripperFirmwareVersion::getParameter(int& controllerType, double& firmwareVersion) const
{
  // Bouml preserved body begin 000BEBF1
  controllerType = this->controllerType;
  firmwareVersion = this->firmwareVersion;
  // Bouml preserved body end 000BEBF1
}

void GripperFirmwareVersion::setParameter(const int controllerType, const double firmwareVersion)
{
  // Bouml preserved body begin 000BEC71
  this->controllerType = controllerType;
  this->firmwareVersion = firmwareVersion;
  // Bouml preserved body end 000BEC71
}

void GripperFirmwareVersion::toString(std::string& value) const
{
  // Bouml preserved body begin 000BECF1
  std::stringstream ss;
  ss << this->name << ": " << this->controllerType << " Version: " << this->firmwareVersion;
  value = ss.str();
  // Bouml preserved body end 000BECF1
}

void GripperFirmwareVersion::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000BED71
  message.stctOutput.commandNumber = FIRMWARE_VERSION;
  message.stctOutput.moduleAddress = GRIPPER;
  message.stctOutput.typeNumber = 0;  //GripperFirmwareVersion
  message.stctOutput.motorNumber = 0;
  message.stctOutput.value = 0;
  // Bouml preserved body end 000BED71
}

void GripperFirmwareVersion::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000BEDF1
  // Bouml preserved body end 000BEDF1
}

GripperBarName::GripperBarName()
{
  // Bouml preserved body begin 00109D71
  this->name = "GripperBarName";
  this->parameterType = API_PARAMETER;
  // Bouml preserved body end 00109D71
}

GripperBarName::~GripperBarName()
{
  // Bouml preserved body begin 00109DF1
  // Bouml preserved body end 00109DF1
}

void GripperBarName::getParameter(std::string& parameter) const
{
  // Bouml preserved body begin 00109E71
  parameter = this->value;
  // Bouml preserved body end 00109E71
}

void GripperBarName::setParameter(const std::string parameter)
{
  // Bouml preserved body begin 00109EF1
  this->value = parameter;
  // Bouml preserved body end 00109EF1
}

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

void GripperBarName::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 00109FF1
  // Bouml preserved body end 00109FF1
}

void GripperBarName::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 0010A071
  // Bouml preserved body end 0010A071
}

CalibrateGripper::CalibrateGripper()
{
  // Bouml preserved body begin 0005F3F1
  this->name = "CalibrateGripper";
  this->parameterType = API_PARAMETER;
  // Bouml preserved body end 0005F3F1
}

CalibrateGripper::~CalibrateGripper()
{
  // Bouml preserved body begin 0005F471
  // Bouml preserved body end 0005F471
}

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

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

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

void CalibrateGripper::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000BE6F1
  // Bouml preserved body end 000BE6F1
}

void CalibrateGripper::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000BE8F1
  // Bouml preserved body end 000BE8F1
}

BarSpacingOffset::BarSpacingOffset()
{
  // Bouml preserved body begin 0005FC71
  this->name = "BarSpacingOffset";
  this->parameterType = API_PARAMETER;
  // Bouml preserved body end 0005FC71
}

BarSpacingOffset::~BarSpacingOffset()
{
  // Bouml preserved body begin 0005FCF1
  // Bouml preserved body end 0005FCF1
}

void BarSpacingOffset::getParameter(quantity<si::length>& parameter) const
{
  // Bouml preserved body begin 0005FD71
  parameter = this->value;
  // Bouml preserved body end 0005FD71
}

void BarSpacingOffset::setParameter(const quantity<si::length>& parameter)
{
  // Bouml preserved body begin 0005FDF1
  if (parameter > 1 * meter || parameter < 0 * meter)
  {
    throw std::out_of_range("The Bar Spacing Offset is only allowed to be less than 1m and bigger than zero");
  }
  this->value = parameter;
  // Bouml preserved body end 0005FDF1
}

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

void BarSpacingOffset::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000BE871
  // Bouml preserved body end 000BE871
}

void BarSpacingOffset::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000BEA71
  // Bouml preserved body end 000BEA71
}

MaxEncoderValue::MaxEncoderValue()
{
  // Bouml preserved body begin 00061B71
  this->name = "MaxEncoderValue";
  this->parameterType = API_PARAMETER;
  // Bouml preserved body end 00061B71
}

MaxEncoderValue::~MaxEncoderValue()
{
  // Bouml preserved body begin 00061BF1
  // Bouml preserved body end 00061BF1
}

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

void MaxEncoderValue::setParameter(const unsigned int parameter)
{
  // Bouml preserved body begin 00061CF1
  this->value = parameter;
  // Bouml preserved body end 00061CF1
}

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

void MaxEncoderValue::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000BE7F1
  // Bouml preserved body end 000BE7F1
}

void MaxEncoderValue::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000BE9F1
  // Bouml preserved body end 000BE9F1
}

MaxTravelDistance::MaxTravelDistance()
{
  // Bouml preserved body begin 000618F1
  this->name = "MaxTravelDistance";
  this->parameterType = API_PARAMETER;
  // Bouml preserved body end 000618F1
}

MaxTravelDistance::~MaxTravelDistance()
{
  // Bouml preserved body begin 00061971
  // Bouml preserved body end 00061971
}

void MaxTravelDistance::getParameter(quantity<si::length>& parameter) const
{
  // Bouml preserved body begin 000619F1
  parameter = this->value;
  // Bouml preserved body end 000619F1
}

void MaxTravelDistance::setParameter(const quantity<si::length>& parameter)
{
  // Bouml preserved body begin 00061A71
  if (parameter > 1 * meter || parameter < 0 * meter)
  {
    throw std::out_of_range("The Max Travel Distance is only allowed to be less than 1m and bigger than zero");
  }
  this->value = parameter;
  // Bouml preserved body end 00061A71
}

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

void MaxTravelDistance::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000BE771
  // Bouml preserved body end 000BE771
}

void MaxTravelDistance::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000BE971
  // Bouml preserved body end 000BE971
}

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

ActualPosition::~ActualPosition()
{
  // Bouml preserved body begin 000E1171
  // Bouml preserved body end 000E1171
}

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

void ActualPosition::setParameter(const int parameter)
{
  // Bouml preserved body begin 000E1271
  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 000E1271
}

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

void ActualPosition::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000E1371
  message.stctOutput.typeNumber = 1; //ActualPosition
  message.stctOutput.value = (uint32)(value * -1);

  // Bouml preserved body end 000E1371
}

void ActualPosition::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000E13F1
  this->value = (int32)message.stctInput.value;
  this->value = this->value * -1;
  // Bouml preserved body end 000E13F1
}

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

PositionSetpoint::~PositionSetpoint()
{
  // Bouml preserved body begin 000E1A71
  // Bouml preserved body end 000E1A71
}

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

void PositionSetpoint::setParameter(const int parameter)
{
  // Bouml preserved body begin 000E1B71
  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 000E1B71
}

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

void PositionSetpoint::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000E1C71

  message.stctOutput.typeNumber = 0; //PositionSetpoint
  message.stctOutput.value = (uint32)(value * -1);

  // Bouml preserved body end 000E1C71
}

void PositionSetpoint::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000E1CF1
  this->value = (int)message.stctInput.value;
  this->value = this->value * -1;

  // Bouml preserved body end 000E1CF1
}

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

TargetPositionReached::~TargetPositionReached()
{
  // Bouml preserved body begin 000FFEF1
  // Bouml preserved body end 000FFEF1
}

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

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

void TargetPositionReached::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 001000F1
  message.stctOutput.typeNumber = 8;  //TargetPositionReached
  if (value)
    message.stctOutput.value = 1;
  else
    message.stctOutput.value = 0;
  // Bouml preserved body end 001000F1
}

void TargetPositionReached::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 00100171
  this->value = message.stctInput.value;
  // Bouml preserved body end 00100171
}

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

ActualVelocity::~ActualVelocity()
{
  // Bouml preserved body begin 000E15F1
  // Bouml preserved body end 000E15F1
}

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

void ActualVelocity::setParameter(const int parameter)
{
  // Bouml preserved body begin 000E16F1
  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 000E16F1
}

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

void ActualVelocity::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000E17F1

  message.stctOutput.typeNumber = 3;  //ActualVelocity
  message.stctOutput.value = (uint32)value;

  // Bouml preserved body end 000E17F1
}

void ActualVelocity::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000E1871
  this->value = (int32)message.stctInput.value;

  // Bouml preserved body end 000E1871
}

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

VelocitySetpoint::~VelocitySetpoint()
{
  // Bouml preserved body begin 000E1EF1
  // Bouml preserved body end 000E1EF1
}

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

void VelocitySetpoint::setParameter(const int parameter)
{
  // Bouml preserved body begin 000E1FF1
  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 000E1FF1
}

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

void VelocitySetpoint::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000E20F1
  message.stctOutput.typeNumber = 2;  //VelocitySetpoint
  message.stctOutput.value = (uint32)value;

  // Bouml preserved body end 000E20F1
}

void VelocitySetpoint::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000E2171
  this->value = (int32)message.stctInput.value;

  // Bouml preserved body end 000E2171
}

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

ActualLoadValue::~ActualLoadValue()
{
  // Bouml preserved body begin 000BBE71
  // Bouml preserved body end 000BBE71
}

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

void ActualLoadValue::setParameter(const unsigned int& parameter)
{
  // Bouml preserved body begin 000BBF71
  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 000BBF71
}

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

void ActualLoadValue::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000BC071

  message.stctOutput.typeNumber = 206;  //ActualLoadValue
  message.stctOutput.value = value;

  // Bouml preserved body end 000BC071
}

void ActualLoadValue::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000BC0F1
  this->value = message.stctInput.value;
  // Bouml preserved body end 000BC0F1
}

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

ChopperBlankTime::~ChopperBlankTime()
{
  // Bouml preserved body begin 000B5B71
  // Bouml preserved body end 000B5B71
}

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

void ChopperBlankTime::setParameter(const unsigned int& parameter)
{
  // Bouml preserved body begin 000B5C71
  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 000B5C71
}

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

void ChopperBlankTime::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000B5D71

  message.stctOutput.typeNumber = 162;  //ChopperBlankTime
  message.stctOutput.value = value;

  // Bouml preserved body end 000B5D71
}

void ChopperBlankTime::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000B5DF1
  this->value = message.stctInput.value;
  // Bouml preserved body end 000B5DF1
}

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

ChopperHysteresisDecrement::~ChopperHysteresisDecrement()
{
  // Bouml preserved body begin 000B6471
  // Bouml preserved body end 000B6471
}

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

void ChopperHysteresisDecrement::setParameter(const unsigned int& parameter)
{
  // Bouml preserved body begin 000B6571
  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 000B6571
}

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

void ChopperHysteresisDecrement::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000B6671
  message.stctOutput.typeNumber = 164;  //ChopperHysteresisDecrement
  message.stctOutput.value = value;
  // Bouml preserved body end 000B6671
}

void ChopperHysteresisDecrement::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000B66F1
  this->value = message.stctInput.value;
  // Bouml preserved body end 000B66F1
}

ChopperHysteresisEnd::ChopperHysteresisEnd()
{
  // Bouml preserved body begin 000B6871
  this->name = "ChopperHysteresisEnd";
  this->lowerLimit = -3;
  this->upperLimit = 12;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 000B6871
}

ChopperHysteresisEnd::~ChopperHysteresisEnd()
{
  // Bouml preserved body begin 000B68F1
  // Bouml preserved body end 000B68F1
}

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

void ChopperHysteresisEnd::setParameter(const int parameter)
{
  // Bouml preserved body begin 000B69F1
  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 000B69F1
}

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

void ChopperHysteresisEnd::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000B6AF1
  message.stctOutput.typeNumber = 165;  //ChopperHysteresisEnd
  message.stctOutput.value = value;
  // Bouml preserved body end 000B6AF1
}

void ChopperHysteresisEnd::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000B6B71
  this->value = (int32)message.stctInput.value;
  // Bouml preserved body end 000B6B71
}

ChopperHysteresisStart::ChopperHysteresisStart()
{
  // Bouml preserved body begin 00107271
  this->name = "ChopperHysteresisStart";
  this->lowerLimit = 0;
  this->upperLimit = 8;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 00107271
}

ChopperHysteresisStart::~ChopperHysteresisStart()
{
  // Bouml preserved body begin 001072F1
  // Bouml preserved body end 001072F1
}

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

void ChopperHysteresisStart::setParameter(const int parameter)
{
  // Bouml preserved body begin 001073F1
  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 001073F1
}

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

void ChopperHysteresisStart::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 001074F1
  message.stctOutput.typeNumber = 166;  //ChopperHysteresisStart
  message.stctOutput.value = value;
  // Bouml preserved body end 001074F1
}

void ChopperHysteresisStart::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 00107571
  this->value = (int32)message.stctInput.value;
  // Bouml preserved body end 00107571
}

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

ChopperMode::~ChopperMode()
{
  // Bouml preserved body begin 000B5FF1
  // Bouml preserved body end 000B5FF1
}

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

void ChopperMode::setParameter(const bool parameter)
{
  // Bouml preserved body begin 000B60F1

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

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

void ChopperMode::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000B61F1
  message.stctOutput.typeNumber = 163;  //ChopperMode
  message.stctOutput.value = value;
  // Bouml preserved body end 000B61F1
}

void ChopperMode::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000B6271
  this->value = message.stctInput.value;
  // Bouml preserved body end 000B6271
}

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

ChopperOffTime::~ChopperOffTime()
{
  // Bouml preserved body begin 000B6D71
  // Bouml preserved body end 000B6D71
}

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

void ChopperOffTime::setParameter(const unsigned int& parameter)
{
  // Bouml preserved body begin 000B6E71
  if (this->lowerLimit > parameter)
  {
    throw std::out_of_range("The parameter exceeds the lower limit");
  }
  if (parameter == 1)
  {
    throw std::out_of_range("One is not allowed for this parameter");
  }
  if (this->upperLimit < parameter)
  {
    throw std::out_of_range("The parameter exceeds the upper limit");
  }

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

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

void ChopperOffTime::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000B6F71
  message.stctOutput.typeNumber = 167;   //ChopperOffTime
  message.stctOutput.value = value;
  // Bouml preserved body end 000B6F71
}

void ChopperOffTime::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000B6FF1
  this->value = message.stctInput.value;
  // Bouml preserved body end 000B6FF1
}

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

DoubleStepEnable::~DoubleStepEnable()
{
  // Bouml preserved body begin 000B56F1
  // Bouml preserved body end 000B56F1
}

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

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

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

void DoubleStepEnable::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000B58F1
  message.stctOutput.typeNumber = 161;  //DoubleStepEnable
  message.stctOutput.value = value;
  // Bouml preserved body end 000B58F1
}

void DoubleStepEnable::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000B5971
  this->value = message.stctInput.value;

  // Bouml preserved body end 000B5971
}

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

ErrorFlags::~ErrorFlags()
{
  // Bouml preserved body begin 000BC2F1
  // Bouml preserved body end 000BC2F1
}

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

void ErrorFlags::setParameter(const unsigned int& parameter)
{
  // Bouml preserved body begin 000BC3F1

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

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

void ErrorFlags::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000BC4F1
  message.stctOutput.typeNumber = 208;   //ErrorFlags
  message.stctOutput.value = value;
  // Bouml preserved body end 000BC4F1
}

void ErrorFlags::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000BC571
  this->value = message.stctInput.value;

  // Bouml preserved body end 000BC571
}

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

Freewheeling::~Freewheeling()
{
  // Bouml preserved body begin 000BB9F1
  // Bouml preserved body end 000BB9F1
}

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

void Freewheeling::setParameter(const unsigned int& parameter)
{
  // Bouml preserved body begin 000BBAF1
  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 000BBAF1
}

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

void Freewheeling::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000BBBF1
  message.stctOutput.typeNumber = 204;   //Freewheeling
  message.stctOutput.value = value;
  // Bouml preserved body end 000BBBF1
}

void Freewheeling::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000BBC71
  this->value = message.stctInput.value;

  // Bouml preserved body end 000BBC71
}

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

MaximumAcceleration::~MaximumAcceleration()
{
  // Bouml preserved body begin 000B32F1
  // Bouml preserved body end 000B32F1
}

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

void MaximumAcceleration::setParameter(const int parameter)
{
  // Bouml preserved body begin 000B33F1
  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 000B33F1
}

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

void MaximumAcceleration::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000B34F1
  message.stctOutput.typeNumber = 5;  //MaximumAcceleration
  message.stctOutput.value = value;
  // Bouml preserved body end 000B34F1
}

void MaximumAcceleration::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000B3571
  this->value = message.stctInput.value;
  // Bouml preserved body end 000B3571
}

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

MaximumCurrent::~MaximumCurrent()
{
  // Bouml preserved body begin 000B3771
  // Bouml preserved body end 000B3771
}

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

void MaximumCurrent::setParameter(const int parameter)
{
  // Bouml preserved body begin 000B3871
  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 000B3871
}

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

void MaximumCurrent::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000B3971
  message.stctOutput.typeNumber = 6;  //MaximumCurrent
  message.stctOutput.value = value;
  // Bouml preserved body end 000B3971
}

void MaximumCurrent::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000B39F1
  this->value = message.stctInput.value;
  // Bouml preserved body end 000B39F1
}

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

MaximumPositioningSpeed::~MaximumPositioningSpeed()
{
  // Bouml preserved body begin 000B2E71
  // Bouml preserved body end 000B2E71
}

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

void MaximumPositioningSpeed::setParameter(const int parameter)
{
  // Bouml preserved body begin 000B2F71
  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 000B2F71
}

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

void MaximumPositioningSpeed::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000B3071
  message.stctOutput.typeNumber = 4; //MaximumPositioningSpeed
  message.stctOutput.value = value;
  // Bouml preserved body end 000B3071
}

void MaximumPositioningSpeed::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000B30F1
  this->value = message.stctInput.value;
  // Bouml preserved body end 000B30F1
}

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

MicrostepResolution::~MicrostepResolution()
{
  // Bouml preserved body begin 000B44F1
  // Bouml preserved body end 000B44F1
}

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

void MicrostepResolution::setParameter(const unsigned int& parameter)
{
  // Bouml preserved body begin 000B45F1
  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 000B45F1
}

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

void MicrostepResolution::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000B46F1
  message.stctOutput.typeNumber = 140;  //MicrostepResolution
  message.stctOutput.value = value;
  // Bouml preserved body end 000B46F1
}

void MicrostepResolution::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000B4771
  this->value = message.stctInput.value;

  // Bouml preserved body end 000B4771
}

PowerDownDelay::PowerDownDelay()
{
  // Bouml preserved body begin 000BC6F1
  this->name = "PowerDownDelay";
  this->lowerLimit = 1;
  this->upperLimit = 65535;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 000BC6F1
}

PowerDownDelay::~PowerDownDelay()
{
  // Bouml preserved body begin 000BC771
  // Bouml preserved body end 000BC771
}

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

void PowerDownDelay::setParameter(const unsigned int& parameter)
{
  // Bouml preserved body begin 000BC871
  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 000BC871
}

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

void PowerDownDelay::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000BC971
  message.stctOutput.typeNumber = 214;  //PowerDownDelay
  message.stctOutput.value = value;
  // Bouml preserved body end 000BC971
}

void PowerDownDelay::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000BC9F1
  this->value = message.stctInput.value;
  // Bouml preserved body end 000BC9F1
}

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

PulseDivisor::~PulseDivisor()
{
  // Bouml preserved body begin 000B4DF1
  // Bouml preserved body end 000B4DF1
}

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

void PulseDivisor::setParameter(const unsigned int& parameter)
{
  // Bouml preserved body begin 000B4EF1
  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 000B4EF1
}

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

void PulseDivisor::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000B4FF1
  message.stctOutput.typeNumber = 154;  //PulseDivisor
  message.stctOutput.value = value;
  // Bouml preserved body end 000B4FF1
}

void PulseDivisor::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000B5071
  this->value = message.stctInput.value;
  // Bouml preserved body end 000B5071
}

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

RampDivisor::~RampDivisor()
{
  // Bouml preserved body begin 000B4971
  // Bouml preserved body end 000B4971
}

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

void RampDivisor::setParameter(const unsigned int& parameter)
{
  // Bouml preserved body begin 000B4A71
  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 000B4A71
}

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

void RampDivisor::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000B4B71
  message.stctOutput.typeNumber = 153;  //RampDivisor
  message.stctOutput.value = value;
  // Bouml preserved body end 000B4B71
}

void RampDivisor::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000B4BF1
  this->value = message.stctInput.value;
  // Bouml preserved body end 000B4BF1
}

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

RampMode::~RampMode()
{
  // Bouml preserved body begin 000B4071
  // Bouml preserved body end 000B4071
}

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

void RampMode::setParameter(const unsigned int& parameter)
{
  // Bouml preserved body begin 000B4171
  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 000B4171
}

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

void RampMode::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000B4271
  message.stctOutput.typeNumber = 138;  //RampMode
  message.stctOutput.value = value;
  // Bouml preserved body end 000B4271
}

void RampMode::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000B42F1
  this->value = message.stctInput.value;
  // Bouml preserved body end 000B42F1
}

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

ShortDetectionTimer::~ShortDetectionTimer()
{
  // Bouml preserved body begin 000B9EF1
  // Bouml preserved body end 000B9EF1
}

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

void ShortDetectionTimer::setParameter(const unsigned int& parameter)
{
  // Bouml preserved body begin 000B9FF1
  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 000B9FF1
}

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

void ShortDetectionTimer::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000BA0F1
  message.stctOutput.typeNumber = 178;  //ShortDetectionTimer
  message.stctOutput.value = value;
  // Bouml preserved body end 000BA0F1
}

void ShortDetectionTimer::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000BA171
  this->value = message.stctInput.value;
  // Bouml preserved body end 000BA171
}

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

ShortProtectionDisable::~ShortProtectionDisable()
{
  // Bouml preserved body begin 000B9A71
  // Bouml preserved body end 000B9A71
}

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

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

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

void ShortProtectionDisable::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000B9C71
  message.stctOutput.typeNumber = 177;  //ShortProtectionDisable
  message.stctOutput.value = value;
  // Bouml preserved body end 000B9C71
}

void ShortProtectionDisable::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000B9CF1
  this->value = message.stctInput.value;
  // Bouml preserved body end 000B9CF1
}

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

SlopeControlHighSide::~SlopeControlHighSide()
{
  // Bouml preserved body begin 000B9171
  // Bouml preserved body end 000B9171
}

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

void SlopeControlHighSide::setParameter(const unsigned int& parameter)
{
  // Bouml preserved body begin 000B9271
  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 000B9271
}

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

void SlopeControlHighSide::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000B9371
  message.stctOutput.typeNumber = 175;  //SlopeControlHighSide
  message.stctOutput.value = value;
  // Bouml preserved body end 000B9371
}

void SlopeControlHighSide::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000B93F1
  this->value = message.stctInput.value;
  // Bouml preserved body end 000B93F1
}

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

SlopeControlLowSide::~SlopeControlLowSide()
{
  // Bouml preserved body begin 000B95F1
  // Bouml preserved body end 000B95F1
}

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

void SlopeControlLowSide::setParameter(const unsigned int& parameter)
{
  // Bouml preserved body begin 000B96F1
  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 000B96F1
}

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

void SlopeControlLowSide::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000B97F1
  message.stctOutput.typeNumber = 176;  //SlopeControlLowSide
  message.stctOutput.value = value;
  // Bouml preserved body end 000B97F1
}

void SlopeControlLowSide::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000B9871
  this->value = message.stctInput.value;
  // Bouml preserved body end 000B9871
}

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

SmartEnergyActualCurrent::~SmartEnergyActualCurrent()
{
  // Bouml preserved body begin 000BA7F1
  // Bouml preserved body end 000BA7F1
}

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

void SmartEnergyActualCurrent::setParameter(const unsigned int& parameter)
{
  // Bouml preserved body begin 000BA8F1
  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 000BA8F1
}

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

void SmartEnergyActualCurrent::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000BA9F1
  message.stctOutput.typeNumber = 180;   //SmartEnergyActualCurrent
  message.stctOutput.value = value;
  // Bouml preserved body end 000BA9F1
}

void SmartEnergyActualCurrent::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000BAA71
  this->value = message.stctInput.value;
  // Bouml preserved body end 000BAA71
}

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

SmartEnergyCurrentDownStep::~SmartEnergyCurrentDownStep()
{
  // Bouml preserved body begin 000B7671
  // Bouml preserved body end 000B7671
}

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

void SmartEnergyCurrentDownStep::setParameter(const unsigned int& parameter)
{
  // Bouml preserved body begin 000B7771
  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 000B7771
}

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

void SmartEnergyCurrentDownStep::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000B7871
  message.stctOutput.typeNumber = 169;   //SmartEnergyCurrentDownStep
  message.stctOutput.value = value;
  // Bouml preserved body end 000B7871
}

void SmartEnergyCurrentDownStep::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000B78F1
  this->value = message.stctInput.value;
  // Bouml preserved body end 000B78F1
}

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

SmartEnergyCurrentMinimum::~SmartEnergyCurrentMinimum()
{
  // Bouml preserved body begin 000B71F1
  // Bouml preserved body end 000B71F1
}

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

void SmartEnergyCurrentMinimum::setParameter(const unsigned int& parameter)
{
  // Bouml preserved body begin 000B72F1
  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 000B72F1
}

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

void SmartEnergyCurrentMinimum::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000B73F1
  message.stctOutput.typeNumber = 168;  //SmartEnergyCurrentMinimum
  message.stctOutput.value = value;
  // Bouml preserved body end 000B73F1
}

void SmartEnergyCurrentMinimum::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000B7471
  this->value = message.stctInput.value;
  // Bouml preserved body end 000B7471
}

SmartEnergyCurrentUpStep::SmartEnergyCurrentUpStep()
{
  // Bouml preserved body begin 000B7EF1
  this->name = "SmartEnergyCurrentUpStep";
  this->lowerLimit = 1;
  this->upperLimit = 3;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 000B7EF1
}

SmartEnergyCurrentUpStep::~SmartEnergyCurrentUpStep()
{
  // Bouml preserved body begin 000B7F71
  // Bouml preserved body end 000B7F71
}

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

void SmartEnergyCurrentUpStep::setParameter(const unsigned int& parameter)
{
  // Bouml preserved body begin 000B8071
  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 000B8071
}

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

void SmartEnergyCurrentUpStep::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000B8171
  message.stctOutput.typeNumber = 171;   //SmartEnergyCurrentUpStep
  message.stctOutput.value = value;
  // Bouml preserved body end 000B8171
}

void SmartEnergyCurrentUpStep::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000B81F1
  this->value = message.stctInput.value;
  // Bouml preserved body end 000B81F1
}

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

SmartEnergyHysteresis::~SmartEnergyHysteresis()
{
  // Bouml preserved body begin 000B7AF1
  // Bouml preserved body end 000B7AF1
}

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

void SmartEnergyHysteresis::setParameter(const unsigned int& parameter)
{
  // Bouml preserved body begin 000B7BF1
  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 000B7BF1
}

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

void SmartEnergyHysteresis::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000B7CF1
  message.stctOutput.typeNumber = 170;   //SmartEnergyHysteresis
  message.stctOutput.value = value;
  // Bouml preserved body end 000B7CF1
}

void SmartEnergyHysteresis::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000B7D71
  this->value = message.stctInput.value;
  // Bouml preserved body end 000B7D71
}

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

SmartEnergyHysteresisStart::~SmartEnergyHysteresisStart()
{
  // Bouml preserved body begin 000B83F1
  // Bouml preserved body end 000B83F1
}

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

void SmartEnergyHysteresisStart::setParameter(const unsigned int& parameter)
{
  // Bouml preserved body begin 000B84F1
  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 000B84F1
}

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

void SmartEnergyHysteresisStart::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000B85F1
  message.stctOutput.typeNumber = 172;  //SmartEnergyHysteresisStart
  message.stctOutput.value = value;
  // Bouml preserved body end 000B85F1
}

void SmartEnergyHysteresisStart::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000B8671
  this->value = message.stctInput.value;
  // Bouml preserved body end 000B8671
}

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

SmartEnergySlowRunCurrent::~SmartEnergySlowRunCurrent()
{
  // Bouml preserved body begin 000BB571
  // Bouml preserved body end 000BB571
}

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

void SmartEnergySlowRunCurrent::setParameter(const unsigned int& parameter)
{
  // Bouml preserved body begin 000BB671
  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 000BB671
}

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

void SmartEnergySlowRunCurrent::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000BB771
  message.stctOutput.typeNumber = 183;   //SmartEnergySlowRunCurrent
  message.stctOutput.value = value;
  // Bouml preserved body end 000BB771
}

void SmartEnergySlowRunCurrent::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000BB7F1
  this->value = message.stctInput.value;
  // Bouml preserved body end 000BB7F1
}

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

SmartEnergyThresholdSpeed::~SmartEnergyThresholdSpeed()
{
  // Bouml preserved body begin 000BB0F1
  // Bouml preserved body end 000BB0F1
}

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

void SmartEnergyThresholdSpeed::setParameter(const unsigned int& parameter)
{
  // Bouml preserved body begin 000BB1F1
  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 000BB1F1
}

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

void SmartEnergyThresholdSpeed::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000BB2F1
  message.stctOutput.typeNumber = 182;  //SmartEnergyThresholdSpeed
  message.stctOutput.value = value;
  // Bouml preserved body end 000BB2F1
}

void SmartEnergyThresholdSpeed::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000BB371
  this->value = message.stctInput.value;
  // Bouml preserved body end 000BB371
}

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

StallGuard2FilterEnable::~StallGuard2FilterEnable()
{
  // Bouml preserved body begin 000B8871
  // Bouml preserved body end 000B8871
}

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

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

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

void StallGuard2FilterEnable::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000B8A71
  message.stctOutput.typeNumber = 173;  //StallGuard2FilterEnable
  message.stctOutput.value = value;
  // Bouml preserved body end 000B8A71
}

void StallGuard2FilterEnable::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000B8AF1
  this->value = message.stctInput.value;
  // Bouml preserved body end 000B8AF1
}

StallGuard2Threshold::StallGuard2Threshold()
{
  // Bouml preserved body begin 000B8C71
  this->name = "StallGuard2Threshold";
  this->lowerLimit = -64;
  this->upperLimit = 63;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 000B8C71
}

StallGuard2Threshold::~StallGuard2Threshold()
{
  // Bouml preserved body begin 000B8CF1
  // Bouml preserved body end 000B8CF1
}

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

void StallGuard2Threshold::setParameter(const int parameter)
{
  // Bouml preserved body begin 000B8DF1
  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 000B8DF1
}

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

void StallGuard2Threshold::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000B8EF1
  message.stctOutput.typeNumber = 174;  //StallGuard2Threshold
  message.stctOutput.value = value;
  // Bouml preserved body end 000B8EF1
}

void StallGuard2Threshold::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000B8F71
  this->value = (int32)message.stctInput.value;
  // Bouml preserved body end 000B8F71
}

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

StandbyCurrent::~StandbyCurrent()
{
  // Bouml preserved body begin 000B3BF1
  // Bouml preserved body end 000B3BF1
}

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

void StandbyCurrent::setParameter(const int parameter)
{
  // Bouml preserved body begin 000B3CF1
  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 000B3CF1
}

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

void StandbyCurrent::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000B3DF1
  message.stctOutput.typeNumber = 7;  //StandbyCurrent
  message.stctOutput.value = value;
  // Bouml preserved body end 000B3DF1
}

void StandbyCurrent::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000B3E71
  this->value = message.stctInput.value;
  // Bouml preserved body end 000B3E71
}

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

StepInterpolationEnable::~StepInterpolationEnable()
{
  // Bouml preserved body begin 000B5271
  // Bouml preserved body end 000B5271
}

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

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

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

void StepInterpolationEnable::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000B5471
  message.stctOutput.typeNumber = 160;  //StepInterpolationEnable
  message.stctOutput.value = value;
  // Bouml preserved body end 000B5471
}

void StepInterpolationEnable::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000B54F1
  this->value = message.stctInput.value;
  // Bouml preserved body end 000B54F1
}

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

StopOnStall::~StopOnStall()
{
  // Bouml preserved body begin 000BAC71
  // Bouml preserved body end 000BAC71
}

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

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

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

void StopOnStall::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000BAE71
  message.stctOutput.typeNumber = 181;  //StopOnStall
  if (value)
    message.stctOutput.value = 1;
  else
    message.stctOutput.value = 0;

  // Bouml preserved body end 000BAE71
}

void StopOnStall::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000BAEF1
  this->value = message.stctInput.value;
  // Bouml preserved body end 000BAEF1
}

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

Vsense::~Vsense()
{
  // Bouml preserved body begin 000BA371
  // Bouml preserved body end 000BA371
}

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

void Vsense::setParameter(const unsigned int& parameter)
{
  // Bouml preserved body begin 000BA471
  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 000BA471
}

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

void Vsense::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 000BA571
  message.stctOutput.typeNumber = 179;  //Vsense
  message.stctOutput.value = value;
  // Bouml preserved body end 000BA571
}

void Vsense::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 000BA5F1
  this->value = message.stctInput.value;
  // Bouml preserved body end 000BA5F1
}

ActualAcceleration::ActualAcceleration()
{
  // Bouml preserved body begin 0010BBF1
  this->name = "ActualAcceleration";
  this->lowerLimit = 0;
  this->upperLimit = 2047;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 0010BBF1
}

ActualAcceleration::~ActualAcceleration()
{
  // Bouml preserved body begin 0010BC71
  // Bouml preserved body end 0010BC71
}

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

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

void ActualAcceleration::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 0010BDF1
  message.stctOutput.typeNumber = 135;  //ActualAcceleration
  message.stctOutput.value = value;
  // Bouml preserved body end 0010BDF1
}

void ActualAcceleration::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 0010BE71
  this->value = message.stctInput.value;
  // Bouml preserved body end 0010BE71
}

MinimumSpeed::MinimumSpeed()
{
  // Bouml preserved body begin 00107B71
  this->name = "MinimumSpeed";
  this->lowerLimit = 0;
  this->upperLimit = 2047;
  this->parameterType = MOTOR_CONTOLLER_PARAMETER;
  // Bouml preserved body end 00107B71
}

MinimumSpeed::~MinimumSpeed()
{
  // Bouml preserved body begin 00107BF1
  // Bouml preserved body end 00107BF1
}

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

void MinimumSpeed::setParameter(const int parameter)
{
  // Bouml preserved body begin 00107CF1
  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 00107CF1
}

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

void MinimumSpeed::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const
{
  // Bouml preserved body begin 00107DF1
  message.stctOutput.typeNumber = 130;  //MinimumSpeed
  message.stctOutput.value = (uint32)value;

  // Bouml preserved body end 00107DF1
}

void MinimumSpeed::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message)
{
  // Bouml preserved body begin 00107E71
  this->value = (int32)message.stctInput.value;
  // Bouml preserved body end 00107E71
}

} // namespace youbot