YouBotGripperParameter.cpp

Go to the documentation of this file.
00001 /****************************************************************
00002  *
00003  * Copyright (c) 2011
00004  * All rights reserved.
00005  *
00006  * Hochschule Bonn-Rhein-Sieg
00007  * University of Applied Sciences
00008  * Computer Science Department
00009  *
00010  * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
00011  *
00012  * Author:
00013  * Jan Paulus, Nico Hochgeschwender, Michael Reckhaus, Azamat Shakhimardanov
00014  * Supervised by:
00015  * Gerhard K. Kraetzschmar
00016  *
00017  * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
00018  *
00019  * This sofware is published under a dual-license: GNU Lesser General Public 
00020  * License LGPL 2.1 and BSD license. The dual-license implies that users of this
00021  * code may choose which terms they prefer.
00022  *
00023  * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
00024  *
00025  * Redistribution and use in source and binary forms, with or without
00026  * modification, are permitted provided that the following conditions are met:
00027  *
00028  *     * Redistributions of source code must retain the above copyright
00029  *       notice, this list of conditions and the following disclaimer.
00030  *     * Redistributions in binary form must reproduce the above copyright
00031  *       notice, this list of conditions and the following disclaimer in the
00032  *       documentation and/or other materials provided with the distribution.
00033  *     * Neither the name of the Hochschule Bonn-Rhein-Sieg nor the names of its
00034  *       contributors may be used to endorse or promote products derived from
00035  *       this software without specific prior written permission.
00036  *
00037  * This program is free software: you can redistribute it and/or modify
00038  * it under the terms of the GNU Lesser General Public License LGPL as
00039  * published by the Free Software Foundation, either version 2.1 of the
00040  * License, or (at your option) any later version or the BSD license.
00041  *
00042  * This program is distributed in the hope that it will be useful,
00043  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00044  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00045  * GNU Lesser General Public License LGPL and the BSD license for more details.
00046  *
00047  * You should have received a copy of the GNU Lesser General Public
00048  * License LGPL and BSD license along with this program.
00049  *
00050  ****************************************************************/
00051 #include "youbot/YouBotGripperParameter.hpp"
00052 namespace youbot {
00053 
00054 YouBotGripperParameter::YouBotGripperParameter() {
00055   // Bouml preserved body begin 0005F0F1
00056   // Bouml preserved body end 0005F0F1
00057 }
00058 
00059 YouBotGripperParameter::~YouBotGripperParameter() {
00060   // Bouml preserved body begin 0005F171
00061   // Bouml preserved body end 0005F171
00062 }
00063 
00064 GripperFirmwareVersion::GripperFirmwareVersion() {
00065   // Bouml preserved body begin 000BEAF1
00066     this->name = "FirmwareVersion";
00067     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
00068   // Bouml preserved body end 000BEAF1
00069 }
00070 
00071 GripperFirmwareVersion::~GripperFirmwareVersion() {
00072   // Bouml preserved body begin 000BEB71
00073   // Bouml preserved body end 000BEB71
00074 }
00075 
00076 void GripperFirmwareVersion::getParameter(int& controllerType, double& firmwareVersion) const {
00077   // Bouml preserved body begin 000BEBF1
00078     controllerType = this->controllerType;
00079     firmwareVersion = this->firmwareVersion;
00080   // Bouml preserved body end 000BEBF1
00081 }
00082 
00083 void GripperFirmwareVersion::setParameter(const int controllerType, const double firmwareVersion) {
00084   // Bouml preserved body begin 000BEC71
00085     this->controllerType = controllerType;
00086     this->firmwareVersion = firmwareVersion;
00087   // Bouml preserved body end 000BEC71
00088 }
00089 
00090 void GripperFirmwareVersion::toString(std::string& value) const {
00091   // Bouml preserved body begin 000BECF1
00092   std::stringstream ss;
00093   ss << this->name << ": " << this->controllerType << " Version: " << this->firmwareVersion;
00094   value  = ss.str();
00095   // Bouml preserved body end 000BECF1
00096 }
00097 
00098 void GripperFirmwareVersion::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
00099   // Bouml preserved body begin 000BED71
00100     message.stctOutput.commandNumber = FIRMWARE_VERSION;
00101     message.stctOutput.moduleAddress = GRIPPER;
00102     message.stctOutput.typeNumber = 0;  //GripperFirmwareVersion
00103     message.stctOutput.motorNumber = 0;
00104     message.stctOutput.value = 0;
00105   // Bouml preserved body end 000BED71
00106 }
00107 
00108 void GripperFirmwareVersion::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
00109   // Bouml preserved body begin 000BEDF1
00110   // Bouml preserved body end 000BEDF1
00111 }
00112 
00113 GripperBarName::GripperBarName() {
00114   // Bouml preserved body begin 00109D71
00115     this->name = "GripperBarName";
00116     this->parameterType = API_PARAMETER;
00117   // Bouml preserved body end 00109D71
00118 }
00119 
00120 GripperBarName::~GripperBarName() {
00121   // Bouml preserved body begin 00109DF1
00122   // Bouml preserved body end 00109DF1
00123 }
00124 
00125 void GripperBarName::getParameter(std::string& parameter) const {
00126   // Bouml preserved body begin 00109E71
00127     parameter = this->value;
00128   // Bouml preserved body end 00109E71
00129 }
00130 
00131 void GripperBarName::setParameter(const std::string parameter) {
00132   // Bouml preserved body begin 00109EF1
00133     this->value = parameter;
00134   // Bouml preserved body end 00109EF1
00135 }
00136 
00137 void GripperBarName::toString(std::string& value) const {
00138   // Bouml preserved body begin 00109F71
00139   std::stringstream ss;
00140   ss << this->name << ": " << this->value;
00141   value  = ss.str();
00142   // Bouml preserved body end 00109F71
00143 }
00144 
00145 void GripperBarName::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
00146   // Bouml preserved body begin 00109FF1
00147   // Bouml preserved body end 00109FF1
00148 }
00149 
00150 void GripperBarName::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
00151   // Bouml preserved body begin 0010A071
00152   // Bouml preserved body end 0010A071
00153 }
00154 
00155 CalibrateGripper::CalibrateGripper() {
00156   // Bouml preserved body begin 0005F3F1
00157     this->name = "CalibrateGripper";
00158     this->parameterType = API_PARAMETER;
00159   // Bouml preserved body end 0005F3F1
00160 }
00161 
00162 CalibrateGripper::~CalibrateGripper() {
00163   // Bouml preserved body begin 0005F471
00164   // Bouml preserved body end 0005F471
00165 }
00166 
00167 void CalibrateGripper::getParameter(bool& parameter) const {
00168   // Bouml preserved body begin 0005F4F1
00169     parameter = this->value;
00170   // Bouml preserved body end 0005F4F1
00171 }
00172 
00173 void CalibrateGripper::setParameter(const bool parameter) {
00174   // Bouml preserved body begin 0005F571
00175     this->value = parameter;
00176   // Bouml preserved body end 0005F571
00177 }
00178 
00179 void CalibrateGripper::toString(std::string& value) const {
00180   // Bouml preserved body begin 0009F171
00181   std::stringstream ss;
00182   ss << this->name << ": " << this->value;
00183   value  = ss.str();
00184   // Bouml preserved body end 0009F171
00185 }
00186 
00187 void CalibrateGripper::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
00188   // Bouml preserved body begin 000BE6F1
00189   // Bouml preserved body end 000BE6F1
00190 }
00191 
00192 void CalibrateGripper::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
00193   // Bouml preserved body begin 000BE8F1
00194   // Bouml preserved body end 000BE8F1
00195 }
00196 
00197 BarSpacingOffset::BarSpacingOffset() {
00198   // Bouml preserved body begin 0005FC71
00199     this->name = "BarSpacingOffset";
00200     this->parameterType = API_PARAMETER;
00201   // Bouml preserved body end 0005FC71
00202 }
00203 
00204 BarSpacingOffset::~BarSpacingOffset() {
00205   // Bouml preserved body begin 0005FCF1
00206   // Bouml preserved body end 0005FCF1
00207 }
00208 
00209 void BarSpacingOffset::getParameter(quantity<si::length>& parameter) const {
00210   // Bouml preserved body begin 0005FD71
00211     parameter = this->value;
00212   // Bouml preserved body end 0005FD71
00213 }
00214 
00215 void BarSpacingOffset::setParameter(const quantity<si::length>& parameter) {
00216   // Bouml preserved body begin 0005FDF1
00217   if(parameter > 1 *meter || parameter < 0 *meter){
00218     throw std::out_of_range("The Bar Spacing Offset is only allowed to be less than 1m and bigger than zero");
00219   }
00220     this->value = parameter;
00221   // Bouml preserved body end 0005FDF1
00222 }
00223 
00224 void BarSpacingOffset::toString(std::string& value) const {
00225   // Bouml preserved body begin 0009F1F1
00226   std::stringstream ss;
00227   ss << this->name << ": " << this->value;
00228   value  = ss.str();
00229   // Bouml preserved body end 0009F1F1
00230 }
00231 
00232 void BarSpacingOffset::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
00233   // Bouml preserved body begin 000BE871
00234   // Bouml preserved body end 000BE871
00235 }
00236 
00237 void BarSpacingOffset::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
00238   // Bouml preserved body begin 000BEA71
00239   // Bouml preserved body end 000BEA71
00240 }
00241 
00242 MaxEncoderValue::MaxEncoderValue() {
00243   // Bouml preserved body begin 00061B71
00244     this->name = "MaxEncoderValue";
00245     this->parameterType = API_PARAMETER;
00246   // Bouml preserved body end 00061B71
00247 }
00248 
00249 MaxEncoderValue::~MaxEncoderValue() {
00250   // Bouml preserved body begin 00061BF1
00251   // Bouml preserved body end 00061BF1
00252 }
00253 
00254 void MaxEncoderValue::getParameter(unsigned int& parameter) const {
00255   // Bouml preserved body begin 00061C71
00256     parameter = this->value;
00257   // Bouml preserved body end 00061C71
00258 }
00259 
00260 void MaxEncoderValue::setParameter(const unsigned int parameter) {
00261   // Bouml preserved body begin 00061CF1
00262     this->value = parameter;
00263   // Bouml preserved body end 00061CF1
00264 }
00265 
00266 void MaxEncoderValue::toString(std::string& value) const {
00267   // Bouml preserved body begin 0009F0F1
00268   std::stringstream ss;
00269   ss << this->name << ": " << this->value;
00270   value  = ss.str();
00271   // Bouml preserved body end 0009F0F1
00272 }
00273 
00274 void MaxEncoderValue::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
00275   // Bouml preserved body begin 000BE7F1
00276   // Bouml preserved body end 000BE7F1
00277 }
00278 
00279 void MaxEncoderValue::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
00280   // Bouml preserved body begin 000BE9F1
00281   // Bouml preserved body end 000BE9F1
00282 }
00283 
00284 MaxTravelDistance::MaxTravelDistance() {
00285   // Bouml preserved body begin 000618F1
00286     this->name = "MaxTravelDistance";
00287     this->parameterType = API_PARAMETER;
00288   // Bouml preserved body end 000618F1
00289 }
00290 
00291 MaxTravelDistance::~MaxTravelDistance() {
00292   // Bouml preserved body begin 00061971
00293   // Bouml preserved body end 00061971
00294 }
00295 
00296 void MaxTravelDistance::getParameter(quantity<si::length>& parameter) const {
00297   // Bouml preserved body begin 000619F1
00298     parameter = this->value;
00299   // Bouml preserved body end 000619F1
00300 }
00301 
00302 void MaxTravelDistance::setParameter(const quantity<si::length>& parameter) {
00303   // Bouml preserved body begin 00061A71
00304   if(parameter > 1 *meter || parameter < 0 *meter){
00305     throw std::out_of_range("The Max Travel Distance is only allowed to be less than 1m and bigger than zero");
00306   }
00307     this->value = parameter;
00308   // Bouml preserved body end 00061A71
00309 }
00310 
00311 void MaxTravelDistance::toString(std::string& value) const {
00312   // Bouml preserved body begin 0009F071
00313   std::stringstream ss;
00314   ss << this->name << ": " << this->value;
00315   value  = ss.str();
00316   // Bouml preserved body end 0009F071
00317 }
00318 
00319 void MaxTravelDistance::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
00320   // Bouml preserved body begin 000BE771
00321   // Bouml preserved body end 000BE771
00322 }
00323 
00324 void MaxTravelDistance::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
00325   // Bouml preserved body begin 000BE971
00326   // Bouml preserved body end 000BE971
00327 }
00328 
00329 ActualPosition::ActualPosition() {
00330   // Bouml preserved body begin 000E10F1
00331     this->name = "ActualPosition";
00332     this->lowerLimit = INT_MIN;
00333     this->upperLimit = INT_MAX;
00334     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
00335   // Bouml preserved body end 000E10F1
00336 }
00337 
00338 ActualPosition::~ActualPosition() {
00339   // Bouml preserved body begin 000E1171
00340   // Bouml preserved body end 000E1171
00341 }
00342 
00343 void ActualPosition::getParameter(int& parameter) const {
00344   // Bouml preserved body begin 000E11F1
00345     parameter = this->value;
00346   // Bouml preserved body end 000E11F1
00347 }
00348 
00349 void ActualPosition::setParameter(const int parameter) {
00350   // Bouml preserved body begin 000E1271
00351     if (this->lowerLimit > parameter) {
00352       throw std::out_of_range("The parameter exceeds the lower limit");
00353     }
00354     if (this->upperLimit < parameter) {
00355       throw std::out_of_range("The parameter exceeds the upper limit");
00356     }
00357 
00358     this->value = parameter;
00359   // Bouml preserved body end 000E1271
00360 }
00361 
00362 void ActualPosition::toString(std::string& value) const {
00363   // Bouml preserved body begin 000E12F1
00364   std::stringstream ss;
00365   ss << this->name << ": " << this->value;
00366   value  = ss.str();
00367   // Bouml preserved body end 000E12F1
00368 }
00369 
00370 void ActualPosition::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
00371   // Bouml preserved body begin 000E1371
00372     message.stctOutput.typeNumber = 1; //ActualPosition
00373     message.stctOutput.value = (uint32)(value * -1);
00374 
00375   // Bouml preserved body end 000E1371
00376 }
00377 
00378 void ActualPosition::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
00379   // Bouml preserved body begin 000E13F1
00380     this->value = (int32)message.stctInput.value;
00381     this->value = this->value * -1;
00382   // Bouml preserved body end 000E13F1
00383 }
00384 
00385 PositionSetpoint::PositionSetpoint() {
00386   // Bouml preserved body begin 000E19F1
00387     this->name = "PositionSetpoint";
00388     this->lowerLimit = INT_MIN;
00389     this->upperLimit = INT_MAX;
00390     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
00391   // Bouml preserved body end 000E19F1
00392 }
00393 
00394 PositionSetpoint::~PositionSetpoint() {
00395   // Bouml preserved body begin 000E1A71
00396   // Bouml preserved body end 000E1A71
00397 }
00398 
00399 void PositionSetpoint::getParameter(int& parameter) const {
00400   // Bouml preserved body begin 000E1AF1
00401     parameter = this->value;
00402   // Bouml preserved body end 000E1AF1
00403 }
00404 
00405 void PositionSetpoint::setParameter(const int parameter) {
00406   // Bouml preserved body begin 000E1B71
00407     if (this->lowerLimit > parameter) {
00408       throw std::out_of_range("The parameter exceeds the lower limit");
00409     }
00410     if (this->upperLimit < parameter) {
00411       throw std::out_of_range("The parameter exceeds the upper limit");
00412     }
00413 
00414     this->value = parameter;
00415   // Bouml preserved body end 000E1B71
00416 }
00417 
00418 void PositionSetpoint::toString(std::string& value) const {
00419   // Bouml preserved body begin 000E1BF1
00420   std::stringstream ss;
00421   ss << this->name << ": " << this->value;
00422   value  = ss.str();
00423   // Bouml preserved body end 000E1BF1
00424 }
00425 
00426 void PositionSetpoint::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
00427   // Bouml preserved body begin 000E1C71
00428 
00429     message.stctOutput.typeNumber = 0; //PositionSetpoint
00430     message.stctOutput.value = (uint32)(value * -1);
00431 
00432   // Bouml preserved body end 000E1C71
00433 }
00434 
00435 void PositionSetpoint::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
00436   // Bouml preserved body begin 000E1CF1
00437     this->value = (int)message.stctInput.value;
00438     this->value = this->value * -1;
00439 
00440   // Bouml preserved body end 000E1CF1
00441 }
00442 
00443 TargetPositionReached::TargetPositionReached() {
00444   // Bouml preserved body begin 000FFE71
00445     this->name = "TargetPositionReached";
00446     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
00447   // Bouml preserved body end 000FFE71
00448 }
00449 
00450 TargetPositionReached::~TargetPositionReached() {
00451   // Bouml preserved body begin 000FFEF1
00452   // Bouml preserved body end 000FFEF1
00453 }
00454 
00455 void TargetPositionReached::getParameter(bool& parameter) const {
00456   // Bouml preserved body begin 000FFF71
00457     parameter = this->value;
00458   // Bouml preserved body end 000FFF71
00459 }
00460 
00461 void TargetPositionReached::toString(std::string& value) const {
00462   // Bouml preserved body begin 00100071
00463   std::stringstream ss;
00464   ss << this->name << ": " << this->value;
00465   value  = ss.str();
00466   // Bouml preserved body end 00100071
00467 }
00468 
00469 void TargetPositionReached::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
00470   // Bouml preserved body begin 001000F1
00471     message.stctOutput.typeNumber = 8;  //TargetPositionReached
00472     if(value)
00473       message.stctOutput.value = 1;
00474     else
00475       message.stctOutput.value = 0;
00476   // Bouml preserved body end 001000F1
00477 }
00478 
00479 void TargetPositionReached::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
00480   // Bouml preserved body begin 00100171
00481     this->value = message.stctInput.value;
00482   // Bouml preserved body end 00100171
00483 }
00484 
00485 ActualVelocity::ActualVelocity() {
00486   // Bouml preserved body begin 000E1571
00487     this->name = "ActualVelocity";
00488     this->lowerLimit = INT_MIN;
00489     this->upperLimit = INT_MAX;
00490     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
00491   // Bouml preserved body end 000E1571
00492 }
00493 
00494 ActualVelocity::~ActualVelocity() {
00495   // Bouml preserved body begin 000E15F1
00496   // Bouml preserved body end 000E15F1
00497 }
00498 
00499 void ActualVelocity::getParameter(int& parameter) const {
00500   // Bouml preserved body begin 000E1671
00501     parameter = this->value;
00502   // Bouml preserved body end 000E1671
00503 }
00504 
00505 void ActualVelocity::setParameter(const int parameter) {
00506   // Bouml preserved body begin 000E16F1
00507     if (this->lowerLimit > parameter) {
00508       throw std::out_of_range("The parameter exceeds the lower limit");
00509     }
00510     if (this->upperLimit < parameter) {
00511       throw std::out_of_range("The parameter exceeds the upper limit");
00512     }
00513 
00514     this->value = parameter;
00515   // Bouml preserved body end 000E16F1
00516 }
00517 
00518 void ActualVelocity::toString(std::string& value) const {
00519   // Bouml preserved body begin 000E1771
00520   std::stringstream ss;
00521   ss << this->name << ": " << this->value;
00522   value  = ss.str();
00523   // Bouml preserved body end 000E1771
00524 }
00525 
00526 void ActualVelocity::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
00527   // Bouml preserved body begin 000E17F1
00528 
00529     message.stctOutput.typeNumber = 3;  //ActualVelocity
00530     message.stctOutput.value = (uint32)value;
00531 
00532   // Bouml preserved body end 000E17F1
00533 }
00534 
00535 void ActualVelocity::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
00536   // Bouml preserved body begin 000E1871
00537     this->value = (int32)message.stctInput.value;
00538 
00539   // Bouml preserved body end 000E1871
00540 }
00541 
00542 VelocitySetpoint::VelocitySetpoint() {
00543   // Bouml preserved body begin 000E1E71
00544     this->name = "VelocitySetpoint";
00545     this->lowerLimit = INT_MIN;
00546     this->upperLimit = INT_MAX;
00547     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
00548   // Bouml preserved body end 000E1E71
00549 }
00550 
00551 VelocitySetpoint::~VelocitySetpoint() {
00552   // Bouml preserved body begin 000E1EF1
00553   // Bouml preserved body end 000E1EF1
00554 }
00555 
00556 void VelocitySetpoint::getParameter(int& parameter) const {
00557   // Bouml preserved body begin 000E1F71
00558     parameter = this->value;
00559   // Bouml preserved body end 000E1F71
00560 }
00561 
00562 void VelocitySetpoint::setParameter(const int parameter) {
00563   // Bouml preserved body begin 000E1FF1
00564     if (this->lowerLimit > parameter) {
00565       throw std::out_of_range("The parameter exceeds the lower limit");
00566     }
00567     if (this->upperLimit < parameter) {
00568       throw std::out_of_range("The parameter exceeds the upper limit");
00569     }
00570 
00571     this->value = parameter;
00572   // Bouml preserved body end 000E1FF1
00573 }
00574 
00575 void VelocitySetpoint::toString(std::string& value) const {
00576   // Bouml preserved body begin 000E2071
00577   std::stringstream ss;
00578   ss << this->name << ": " << this->value;
00579   value  = ss.str();
00580   // Bouml preserved body end 000E2071
00581 }
00582 
00583 void VelocitySetpoint::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
00584   // Bouml preserved body begin 000E20F1
00585     message.stctOutput.typeNumber = 2;  //VelocitySetpoint
00586     message.stctOutput.value = (uint32)value;
00587 
00588   // Bouml preserved body end 000E20F1
00589 }
00590 
00591 void VelocitySetpoint::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
00592   // Bouml preserved body begin 000E2171
00593     this->value = (int32)message.stctInput.value;
00594 
00595   // Bouml preserved body end 000E2171
00596 }
00597 
00598 ActualLoadValue::ActualLoadValue() {
00599   // Bouml preserved body begin 000BBDF1
00600     this->name = "ActualLoadValue";
00601     this->lowerLimit = 0;
00602     this->upperLimit = 1023;
00603     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
00604   // Bouml preserved body end 000BBDF1
00605 }
00606 
00607 ActualLoadValue::~ActualLoadValue() {
00608   // Bouml preserved body begin 000BBE71
00609   // Bouml preserved body end 000BBE71
00610 }
00611 
00612 void ActualLoadValue::getParameter(unsigned int& parameter) const {
00613   // Bouml preserved body begin 000BBEF1
00614     parameter = this->value;
00615   // Bouml preserved body end 000BBEF1
00616 }
00617 
00618 void ActualLoadValue::setParameter(const unsigned int& parameter) {
00619   // Bouml preserved body begin 000BBF71
00620     if (this->lowerLimit > parameter) {
00621       throw std::out_of_range("The parameter exceeds the lower limit");
00622     }
00623     if (this->upperLimit < parameter) {
00624       throw std::out_of_range("The parameter exceeds the upper limit");
00625     }
00626 
00627     this->value = parameter;
00628   // Bouml preserved body end 000BBF71
00629 }
00630 
00631 void ActualLoadValue::toString(std::string& value) const {
00632   // Bouml preserved body begin 000BBFF1
00633   std::stringstream ss;
00634   ss << this->name << ": " << this->value;
00635   value  = ss.str();
00636   // Bouml preserved body end 000BBFF1
00637 }
00638 
00639 void ActualLoadValue::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
00640   // Bouml preserved body begin 000BC071
00641 
00642     message.stctOutput.typeNumber = 206;  //ActualLoadValue
00643     message.stctOutput.value = value;
00644 
00645   // Bouml preserved body end 000BC071
00646 }
00647 
00648 void ActualLoadValue::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
00649   // Bouml preserved body begin 000BC0F1
00650     this->value  = message.stctInput.value; 
00651   // Bouml preserved body end 000BC0F1
00652 }
00653 
00654 ChopperBlankTime::ChopperBlankTime() {
00655   // Bouml preserved body begin 000B5AF1
00656     this->name = "ChopperBlankTime";
00657     this->lowerLimit = 0;
00658     this->upperLimit = 3;
00659     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
00660   // Bouml preserved body end 000B5AF1
00661 }
00662 
00663 ChopperBlankTime::~ChopperBlankTime() {
00664   // Bouml preserved body begin 000B5B71
00665   // Bouml preserved body end 000B5B71
00666 }
00667 
00668 void ChopperBlankTime::getParameter(unsigned int& parameter) const {
00669   // Bouml preserved body begin 000B5BF1
00670     parameter = this->value;
00671   // Bouml preserved body end 000B5BF1
00672 }
00673 
00674 void ChopperBlankTime::setParameter(const unsigned int& parameter) {
00675   // Bouml preserved body begin 000B5C71
00676     if (this->lowerLimit > parameter) {
00677       throw std::out_of_range("The parameter exceeds the lower limit");
00678     }
00679     if (this->upperLimit < parameter) {
00680       throw std::out_of_range("The parameter exceeds the upper limit");
00681     }
00682 
00683     this->value = parameter;
00684   // Bouml preserved body end 000B5C71
00685 }
00686 
00687 void ChopperBlankTime::toString(std::string& value) const {
00688   // Bouml preserved body begin 000B5CF1
00689   std::stringstream ss;
00690   ss << this->name << ": " << this->value;
00691   value  = ss.str();
00692   // Bouml preserved body end 000B5CF1
00693 }
00694 
00695 void ChopperBlankTime::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
00696   // Bouml preserved body begin 000B5D71
00697 
00698     message.stctOutput.typeNumber = 162;  //ChopperBlankTime
00699     message.stctOutput.value = value;
00700 
00701   // Bouml preserved body end 000B5D71
00702 }
00703 
00704 void ChopperBlankTime::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
00705   // Bouml preserved body begin 000B5DF1
00706     this->value = message.stctInput.value;
00707   // Bouml preserved body end 000B5DF1
00708 }
00709 
00710 ChopperHysteresisDecrement::ChopperHysteresisDecrement() {
00711   // Bouml preserved body begin 000B63F1
00712     this->name = "ChopperHysteresisDecrement";
00713     this->lowerLimit = 0;
00714     this->upperLimit = 3;
00715     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
00716   // Bouml preserved body end 000B63F1
00717 }
00718 
00719 ChopperHysteresisDecrement::~ChopperHysteresisDecrement() {
00720   // Bouml preserved body begin 000B6471
00721   // Bouml preserved body end 000B6471
00722 }
00723 
00724 void ChopperHysteresisDecrement::getParameter(unsigned int& parameter) const {
00725   // Bouml preserved body begin 000B64F1
00726     parameter = this->value;
00727   // Bouml preserved body end 000B64F1
00728 }
00729 
00730 void ChopperHysteresisDecrement::setParameter(const unsigned int& parameter) {
00731   // Bouml preserved body begin 000B6571
00732     if (this->lowerLimit > parameter) {
00733       throw std::out_of_range("The parameter exceeds the lower limit");
00734     }
00735     if (this->upperLimit < parameter) {
00736       throw std::out_of_range("The parameter exceeds the upper limit");
00737     }
00738 
00739     this->value = parameter;
00740   // Bouml preserved body end 000B6571
00741 }
00742 
00743 void ChopperHysteresisDecrement::toString(std::string& value) const {
00744   // Bouml preserved body begin 000B65F1
00745   std::stringstream ss;
00746   ss << this->name << ": " << this->value;
00747   value  = ss.str();
00748   // Bouml preserved body end 000B65F1
00749 }
00750 
00751 void ChopperHysteresisDecrement::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
00752   // Bouml preserved body begin 000B6671
00753     message.stctOutput.typeNumber = 164;  //ChopperHysteresisDecrement
00754     message.stctOutput.value = value;
00755   // Bouml preserved body end 000B6671
00756 }
00757 
00758 void ChopperHysteresisDecrement::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
00759   // Bouml preserved body begin 000B66F1
00760     this->value = message.stctInput.value;
00761   // Bouml preserved body end 000B66F1
00762 }
00763 
00764 ChopperHysteresisEnd::ChopperHysteresisEnd() {
00765   // Bouml preserved body begin 000B6871
00766     this->name = "ChopperHysteresisEnd";
00767     this->lowerLimit = -3;
00768     this->upperLimit = 12;
00769     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
00770   // Bouml preserved body end 000B6871
00771 }
00772 
00773 ChopperHysteresisEnd::~ChopperHysteresisEnd() {
00774   // Bouml preserved body begin 000B68F1
00775   // Bouml preserved body end 000B68F1
00776 }
00777 
00778 void ChopperHysteresisEnd::getParameter(int& parameter) const {
00779   // Bouml preserved body begin 000B6971
00780     parameter = this->value;
00781   // Bouml preserved body end 000B6971
00782 }
00783 
00784 void ChopperHysteresisEnd::setParameter(const int parameter) {
00785   // Bouml preserved body begin 000B69F1
00786     if (this->lowerLimit > parameter) {
00787       throw std::out_of_range("The parameter exceeds the lower limit");
00788     }
00789     if (this->upperLimit < parameter) {
00790       throw std::out_of_range("The parameter exceeds the upper limit");
00791     }
00792 
00793     this->value = parameter;
00794   // Bouml preserved body end 000B69F1
00795 }
00796 
00797 void ChopperHysteresisEnd::toString(std::string& value) const {
00798   // Bouml preserved body begin 000B6A71
00799   std::stringstream ss;
00800   ss << this->name << ": " << this->value;
00801   value  = ss.str();
00802   // Bouml preserved body end 000B6A71
00803 }
00804 
00805 void ChopperHysteresisEnd::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
00806   // Bouml preserved body begin 000B6AF1
00807     message.stctOutput.typeNumber = 165;  //ChopperHysteresisEnd
00808     message.stctOutput.value = value;
00809   // Bouml preserved body end 000B6AF1
00810 }
00811 
00812 void ChopperHysteresisEnd::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
00813   // Bouml preserved body begin 000B6B71
00814     this->value = (int32)message.stctInput.value;
00815   // Bouml preserved body end 000B6B71
00816 }
00817 
00818 ChopperHysteresisStart::ChopperHysteresisStart() {
00819   // Bouml preserved body begin 00107271
00820     this->name = "ChopperHysteresisStart";
00821     this->lowerLimit = 0;
00822     this->upperLimit = 8;
00823     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
00824   // Bouml preserved body end 00107271
00825 }
00826 
00827 ChopperHysteresisStart::~ChopperHysteresisStart() {
00828   // Bouml preserved body begin 001072F1
00829   // Bouml preserved body end 001072F1
00830 }
00831 
00832 void ChopperHysteresisStart::getParameter(int& parameter) const {
00833   // Bouml preserved body begin 00107371
00834     parameter = this->value;
00835   // Bouml preserved body end 00107371
00836 }
00837 
00838 void ChopperHysteresisStart::setParameter(const int parameter) {
00839   // Bouml preserved body begin 001073F1
00840     if (this->lowerLimit > parameter) {
00841       throw std::out_of_range("The parameter exceeds the lower limit");
00842     }
00843     if (this->upperLimit < parameter) {
00844       throw std::out_of_range("The parameter exceeds the upper limit");
00845     }
00846 
00847     this->value = parameter;
00848   // Bouml preserved body end 001073F1
00849 }
00850 
00851 void ChopperHysteresisStart::toString(std::string& value) const {
00852   // Bouml preserved body begin 00107471
00853   std::stringstream ss;
00854   ss << this->name << ": " << this->value;
00855   value  = ss.str();
00856   // Bouml preserved body end 00107471
00857 }
00858 
00859 void ChopperHysteresisStart::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
00860   // Bouml preserved body begin 001074F1
00861     message.stctOutput.typeNumber = 166;  //ChopperHysteresisStart
00862     message.stctOutput.value = value;
00863   // Bouml preserved body end 001074F1
00864 }
00865 
00866 void ChopperHysteresisStart::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
00867   // Bouml preserved body begin 00107571
00868     this->value = (int32)message.stctInput.value;
00869   // Bouml preserved body end 00107571
00870 }
00871 
00872 ChopperMode::ChopperMode() {
00873   // Bouml preserved body begin 000B5F71
00874     this->name = "ChopperMode";
00875     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
00876   // Bouml preserved body end 000B5F71
00877 }
00878 
00879 ChopperMode::~ChopperMode() {
00880   // Bouml preserved body begin 000B5FF1
00881   // Bouml preserved body end 000B5FF1
00882 }
00883 
00884 void ChopperMode::getParameter(bool& parameter) const {
00885   // Bouml preserved body begin 000B6071
00886     parameter = this->value;
00887   // Bouml preserved body end 000B6071
00888 }
00889 
00890 void ChopperMode::setParameter(const bool parameter) {
00891   // Bouml preserved body begin 000B60F1
00892 
00893     this->value = parameter;
00894   // Bouml preserved body end 000B60F1
00895 }
00896 
00897 void ChopperMode::toString(std::string& value) const {
00898   // Bouml preserved body begin 000B6171
00899   std::stringstream ss;
00900   ss << this->name << ": " << this->value;
00901   value  = ss.str();
00902   // Bouml preserved body end 000B6171
00903 }
00904 
00905 void ChopperMode::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
00906   // Bouml preserved body begin 000B61F1
00907     message.stctOutput.typeNumber = 163;  //ChopperMode
00908     message.stctOutput.value = value;
00909   // Bouml preserved body end 000B61F1
00910 }
00911 
00912 void ChopperMode::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
00913   // Bouml preserved body begin 000B6271
00914     this->value = message.stctInput.value;
00915   // Bouml preserved body end 000B6271
00916 }
00917 
00918 ChopperOffTime::ChopperOffTime() {
00919   // Bouml preserved body begin 000B6CF1
00920     this->name = "ChopperOffTime";
00921     this->lowerLimit = 0;
00922     this->upperLimit = 15;
00923     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
00924   // Bouml preserved body end 000B6CF1
00925 }
00926 
00927 ChopperOffTime::~ChopperOffTime() {
00928   // Bouml preserved body begin 000B6D71
00929   // Bouml preserved body end 000B6D71
00930 }
00931 
00932 void ChopperOffTime::getParameter(unsigned int& parameter) const {
00933   // Bouml preserved body begin 000B6DF1
00934     parameter = this->value;
00935   // Bouml preserved body end 000B6DF1
00936 }
00937 
00938 void ChopperOffTime::setParameter(const unsigned int& parameter) {
00939   // Bouml preserved body begin 000B6E71
00940     if (this->lowerLimit > parameter) {
00941       throw std::out_of_range("The parameter exceeds the lower limit");
00942     }
00943     if (parameter == 1) {
00944       throw std::out_of_range("One is not allowed for this parameter");
00945     }
00946     if (this->upperLimit < parameter) {
00947       throw std::out_of_range("The parameter exceeds the upper limit");
00948     }
00949 
00950     this->value = parameter;
00951   // Bouml preserved body end 000B6E71
00952 }
00953 
00954 void ChopperOffTime::toString(std::string& value) const {
00955   // Bouml preserved body begin 000B6EF1
00956   std::stringstream ss;
00957   ss << this->name << ": " << this->value;
00958   value  = ss.str();
00959   // Bouml preserved body end 000B6EF1
00960 }
00961 
00962 void ChopperOffTime::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
00963   // Bouml preserved body begin 000B6F71
00964     message.stctOutput.typeNumber = 167;   //ChopperOffTime
00965     message.stctOutput.value = value;
00966   // Bouml preserved body end 000B6F71
00967 }
00968 
00969 void ChopperOffTime::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
00970   // Bouml preserved body begin 000B6FF1
00971     this->value = message.stctInput.value;
00972   // Bouml preserved body end 000B6FF1
00973 }
00974 
00975 DoubleStepEnable::DoubleStepEnable() {
00976   // Bouml preserved body begin 000B5671
00977     this->name = "DoubleStepEnable";
00978     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
00979   // Bouml preserved body end 000B5671
00980 }
00981 
00982 DoubleStepEnable::~DoubleStepEnable() {
00983   // Bouml preserved body begin 000B56F1
00984   // Bouml preserved body end 000B56F1
00985 }
00986 
00987 void DoubleStepEnable::getParameter(bool& parameter) const {
00988   // Bouml preserved body begin 000B5771
00989     parameter = this->value;
00990   // Bouml preserved body end 000B5771
00991 }
00992 
00993 void DoubleStepEnable::setParameter(const bool parameter) {
00994   // Bouml preserved body begin 000B57F1
00995     this->value = parameter;
00996   // Bouml preserved body end 000B57F1
00997 }
00998 
00999 void DoubleStepEnable::toString(std::string& value) const {
01000   // Bouml preserved body begin 000B5871
01001   std::stringstream ss;
01002   ss << this->name << ": " << this->value;
01003   value  = ss.str();
01004   // Bouml preserved body end 000B5871
01005 }
01006 
01007 void DoubleStepEnable::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
01008   // Bouml preserved body begin 000B58F1
01009     message.stctOutput.typeNumber = 161;  //DoubleStepEnable
01010     message.stctOutput.value = value;
01011   // Bouml preserved body end 000B58F1
01012 }
01013 
01014 void DoubleStepEnable::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
01015   // Bouml preserved body begin 000B5971
01016     this->value = message.stctInput.value;
01017 
01018   // Bouml preserved body end 000B5971
01019 }
01020 
01021 ErrorFlags::ErrorFlags() {
01022   // Bouml preserved body begin 000BC271
01023     this->name = "ErrorFlags";
01024     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
01025   // Bouml preserved body end 000BC271
01026 }
01027 
01028 ErrorFlags::~ErrorFlags() {
01029   // Bouml preserved body begin 000BC2F1
01030   // Bouml preserved body end 000BC2F1
01031 }
01032 
01033 void ErrorFlags::getParameter(unsigned int& parameter) const {
01034   // Bouml preserved body begin 000BC371
01035     parameter = this->value;
01036   // Bouml preserved body end 000BC371
01037 }
01038 
01039 void ErrorFlags::setParameter(const unsigned int& parameter) {
01040   // Bouml preserved body begin 000BC3F1
01041 
01042     this->value = parameter;
01043   // Bouml preserved body end 000BC3F1
01044 }
01045 
01046 void ErrorFlags::toString(std::string& value) const {
01047   // Bouml preserved body begin 000BC471
01048   std::stringstream ss;
01049   ss << this->name << ": " << this->value;
01050   value  = ss.str();
01051   // Bouml preserved body end 000BC471
01052 }
01053 
01054 void ErrorFlags::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
01055   // Bouml preserved body begin 000BC4F1
01056     message.stctOutput.typeNumber = 208;   //ErrorFlags
01057     message.stctOutput.value = value;
01058   // Bouml preserved body end 000BC4F1
01059 }
01060 
01061 void ErrorFlags::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
01062   // Bouml preserved body begin 000BC571
01063     this->value = message.stctInput.value;
01064 
01065   // Bouml preserved body end 000BC571
01066 }
01067 
01068 Freewheeling::Freewheeling() {
01069   // Bouml preserved body begin 000BB971
01070     this->name = "Freewheeling";
01071     this->lowerLimit = 0;
01072     this->upperLimit = 65535;
01073     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
01074   // Bouml preserved body end 000BB971
01075 }
01076 
01077 Freewheeling::~Freewheeling() {
01078   // Bouml preserved body begin 000BB9F1
01079   // Bouml preserved body end 000BB9F1
01080 }
01081 
01082 void Freewheeling::getParameter(unsigned int& parameter) const {
01083   // Bouml preserved body begin 000BBA71
01084     parameter = this->value;
01085   // Bouml preserved body end 000BBA71
01086 }
01087 
01088 void Freewheeling::setParameter(const unsigned int& parameter) {
01089   // Bouml preserved body begin 000BBAF1
01090     if (this->lowerLimit > parameter) {
01091       throw std::out_of_range("The parameter exceeds the lower limit");
01092     }
01093     if (this->upperLimit < parameter) {
01094       throw std::out_of_range("The parameter exceeds the upper limit");
01095     }
01096 
01097     this->value = parameter;
01098   // Bouml preserved body end 000BBAF1
01099 }
01100 
01101 void Freewheeling::toString(std::string& value) const {
01102   // Bouml preserved body begin 000BBB71
01103   std::stringstream ss;
01104   ss << this->name << ": " << this->value;
01105   value  = ss.str();
01106   // Bouml preserved body end 000BBB71
01107 }
01108 
01109 void Freewheeling::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
01110   // Bouml preserved body begin 000BBBF1
01111     message.stctOutput.typeNumber = 204;   //Freewheeling
01112     message.stctOutput.value = value;
01113   // Bouml preserved body end 000BBBF1
01114 }
01115 
01116 void Freewheeling::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
01117   // Bouml preserved body begin 000BBC71
01118     this->value = message.stctInput.value;
01119 
01120   // Bouml preserved body end 000BBC71
01121 }
01122 
01123 MaximumAcceleration::MaximumAcceleration() {
01124   // Bouml preserved body begin 000B3271
01125     this->name = "MaximumAcceleration";
01126     this->lowerLimit = 0;
01127     this->upperLimit = 2047;
01128     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
01129   // Bouml preserved body end 000B3271
01130 }
01131 
01132 MaximumAcceleration::~MaximumAcceleration() {
01133   // Bouml preserved body begin 000B32F1
01134   // Bouml preserved body end 000B32F1
01135 }
01136 
01137 void MaximumAcceleration::getParameter(int& parameter) const {
01138   // Bouml preserved body begin 000B3371
01139     parameter = this->value;
01140   // Bouml preserved body end 000B3371
01141 }
01142 
01143 void MaximumAcceleration::setParameter(const int parameter) {
01144   // Bouml preserved body begin 000B33F1
01145     if (this->lowerLimit > parameter) {
01146       throw std::out_of_range("The parameter exceeds the lower limit");
01147     }
01148     if (this->upperLimit < parameter) {
01149       throw std::out_of_range("The parameter exceeds the upper limit");
01150     }
01151 
01152     this->value = parameter;
01153   // Bouml preserved body end 000B33F1
01154 }
01155 
01156 void MaximumAcceleration::toString(std::string& value) const {
01157   // Bouml preserved body begin 000B3471
01158   std::stringstream ss;
01159   ss << this->name << ": " << this->value;
01160   value  = ss.str();
01161   // Bouml preserved body end 000B3471
01162 }
01163 
01164 void MaximumAcceleration::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
01165   // Bouml preserved body begin 000B34F1
01166     message.stctOutput.typeNumber = 5;  //MaximumAcceleration
01167     message.stctOutput.value = value;
01168   // Bouml preserved body end 000B34F1
01169 }
01170 
01171 void MaximumAcceleration::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
01172   // Bouml preserved body begin 000B3571
01173     this->value = message.stctInput.value;
01174   // Bouml preserved body end 000B3571
01175 }
01176 
01177 MaximumCurrent::MaximumCurrent() {
01178   // Bouml preserved body begin 000B36F1
01179     this->name = "MaximumCurrent";
01180     this->lowerLimit = 0;
01181     this->upperLimit = 255;
01182     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
01183   // Bouml preserved body end 000B36F1
01184 }
01185 
01186 MaximumCurrent::~MaximumCurrent() {
01187   // Bouml preserved body begin 000B3771
01188   // Bouml preserved body end 000B3771
01189 }
01190 
01191 void MaximumCurrent::getParameter(int& parameter) const {
01192   // Bouml preserved body begin 000B37F1
01193     parameter = this->value;
01194   // Bouml preserved body end 000B37F1
01195 }
01196 
01197 void MaximumCurrent::setParameter(const int parameter) {
01198   // Bouml preserved body begin 000B3871
01199     if (this->lowerLimit > parameter) {
01200       throw std::out_of_range("The parameter exceeds the lower limit");
01201     }
01202     if (this->upperLimit < parameter) {
01203       throw std::out_of_range("The parameter exceeds the upper limit");
01204     }
01205 
01206     this->value = parameter;
01207   // Bouml preserved body end 000B3871
01208 }
01209 
01210 void MaximumCurrent::toString(std::string& value) const {
01211   // Bouml preserved body begin 000B38F1
01212   std::stringstream ss;
01213   ss << this->name << ": " << this->value;
01214   value  = ss.str();
01215   // Bouml preserved body end 000B38F1
01216 }
01217 
01218 void MaximumCurrent::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
01219   // Bouml preserved body begin 000B3971
01220     message.stctOutput.typeNumber = 6;  //MaximumCurrent
01221     message.stctOutput.value = value;
01222   // Bouml preserved body end 000B3971
01223 }
01224 
01225 void MaximumCurrent::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
01226   // Bouml preserved body begin 000B39F1
01227     this->value = message.stctInput.value;
01228   // Bouml preserved body end 000B39F1
01229 }
01230 
01231 MaximumPositioningSpeed::MaximumPositioningSpeed() {
01232   // Bouml preserved body begin 000B2DF1
01233     this->name = "MaximumPositioningSpeed";
01234     this->lowerLimit = 0;
01235     this->upperLimit = 2047;
01236     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
01237   // Bouml preserved body end 000B2DF1
01238 }
01239 
01240 MaximumPositioningSpeed::~MaximumPositioningSpeed() {
01241   // Bouml preserved body begin 000B2E71
01242   // Bouml preserved body end 000B2E71
01243 }
01244 
01245 void MaximumPositioningSpeed::getParameter(int& parameter) const {
01246   // Bouml preserved body begin 000B2EF1
01247     parameter = this->value;
01248   // Bouml preserved body end 000B2EF1
01249 }
01250 
01251 void MaximumPositioningSpeed::setParameter(const int parameter) {
01252   // Bouml preserved body begin 000B2F71
01253     if (this->lowerLimit > parameter) {
01254       throw std::out_of_range("The parameter exceeds the lower limit");
01255     }
01256     if (this->upperLimit < parameter) {
01257       throw std::out_of_range("The parameter exceeds the upper limit");
01258     }
01259 
01260     this->value = parameter;
01261   // Bouml preserved body end 000B2F71
01262 }
01263 
01264 void MaximumPositioningSpeed::toString(std::string& value) const {
01265   // Bouml preserved body begin 000B2FF1
01266   std::stringstream ss;
01267   ss << this->name << ": " << this->value;
01268   value  = ss.str();
01269   // Bouml preserved body end 000B2FF1
01270 }
01271 
01272 void MaximumPositioningSpeed::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
01273   // Bouml preserved body begin 000B3071
01274     message.stctOutput.typeNumber = 4; //MaximumPositioningSpeed
01275     message.stctOutput.value = value;
01276   // Bouml preserved body end 000B3071
01277 }
01278 
01279 void MaximumPositioningSpeed::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
01280   // Bouml preserved body begin 000B30F1
01281     this->value = message.stctInput.value;
01282   // Bouml preserved body end 000B30F1
01283 }
01284 
01285 MicrostepResolution::MicrostepResolution() {
01286   // Bouml preserved body begin 000B4471
01287     this->name = "MicrostepResolution";
01288     this->lowerLimit = 0;
01289     this->upperLimit = 8;
01290     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
01291   // Bouml preserved body end 000B4471
01292 }
01293 
01294 MicrostepResolution::~MicrostepResolution() {
01295   // Bouml preserved body begin 000B44F1
01296   // Bouml preserved body end 000B44F1
01297 }
01298 
01299 void MicrostepResolution::getParameter(unsigned int& parameter) const {
01300   // Bouml preserved body begin 000B4571
01301     parameter = this->value;
01302   // Bouml preserved body end 000B4571
01303 }
01304 
01305 void MicrostepResolution::setParameter(const unsigned int& parameter) {
01306   // Bouml preserved body begin 000B45F1
01307     if (this->lowerLimit > parameter) {
01308       throw std::out_of_range("The parameter exceeds the lower limit");
01309     }
01310     if (this->upperLimit < parameter) {
01311       throw std::out_of_range("The parameter exceeds the upper limit");
01312     }
01313 
01314     this->value = parameter;
01315   // Bouml preserved body end 000B45F1
01316 }
01317 
01318 void MicrostepResolution::toString(std::string& value) const {
01319   // Bouml preserved body begin 000B4671
01320   std::stringstream ss;
01321   ss << this->name << ": " << this->value;
01322   value  = ss.str();
01323   // Bouml preserved body end 000B4671
01324 }
01325 
01326 void MicrostepResolution::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
01327   // Bouml preserved body begin 000B46F1
01328     message.stctOutput.typeNumber = 140;  //MicrostepResolution
01329     message.stctOutput.value = value;
01330   // Bouml preserved body end 000B46F1
01331 }
01332 
01333 void MicrostepResolution::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
01334   // Bouml preserved body begin 000B4771
01335     this->value = message.stctInput.value;
01336 
01337   // Bouml preserved body end 000B4771
01338 }
01339 
01340 PowerDownDelay::PowerDownDelay() {
01341   // Bouml preserved body begin 000BC6F1
01342     this->name = "PowerDownDelay";
01343     this->lowerLimit = 1;
01344     this->upperLimit = 65535;
01345     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
01346   // Bouml preserved body end 000BC6F1
01347 }
01348 
01349 PowerDownDelay::~PowerDownDelay() {
01350   // Bouml preserved body begin 000BC771
01351   // Bouml preserved body end 000BC771
01352 }
01353 
01354 void PowerDownDelay::getParameter(unsigned int& parameter) const {
01355   // Bouml preserved body begin 000BC7F1
01356     parameter = this->value;
01357   // Bouml preserved body end 000BC7F1
01358 }
01359 
01360 void PowerDownDelay::setParameter(const unsigned int& parameter) {
01361   // Bouml preserved body begin 000BC871
01362     if (this->lowerLimit > parameter) {
01363       throw std::out_of_range("The parameter exceeds the lower limit");
01364     }
01365     if (this->upperLimit < parameter) {
01366       throw std::out_of_range("The parameter exceeds the upper limit");
01367     }
01368 
01369     this->value = parameter;
01370   // Bouml preserved body end 000BC871
01371 }
01372 
01373 void PowerDownDelay::toString(std::string& value) const {
01374   // Bouml preserved body begin 000BC8F1
01375   std::stringstream ss;
01376   ss << this->name << ": " << this->value;
01377   value  = ss.str();
01378   // Bouml preserved body end 000BC8F1
01379 }
01380 
01381 void PowerDownDelay::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
01382   // Bouml preserved body begin 000BC971
01383     message.stctOutput.typeNumber = 214;  //PowerDownDelay
01384     message.stctOutput.value = value;
01385   // Bouml preserved body end 000BC971
01386 }
01387 
01388 void PowerDownDelay::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
01389   // Bouml preserved body begin 000BC9F1
01390     this->value = message.stctInput.value;
01391   // Bouml preserved body end 000BC9F1
01392 }
01393 
01394 PulseDivisor::PulseDivisor() {
01395   // Bouml preserved body begin 000B4D71
01396     this->name = "PulseDivisor";
01397     this->lowerLimit = 0;
01398     this->upperLimit = 13;
01399     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
01400   // Bouml preserved body end 000B4D71
01401 }
01402 
01403 PulseDivisor::~PulseDivisor() {
01404   // Bouml preserved body begin 000B4DF1
01405   // Bouml preserved body end 000B4DF1
01406 }
01407 
01408 void PulseDivisor::getParameter(unsigned int& parameter) const {
01409   // Bouml preserved body begin 000B4E71
01410     parameter = this->value;
01411   // Bouml preserved body end 000B4E71
01412 }
01413 
01414 void PulseDivisor::setParameter(const unsigned int& parameter) {
01415   // Bouml preserved body begin 000B4EF1
01416     if (this->lowerLimit > parameter) {
01417       throw std::out_of_range("The parameter exceeds the lower limit");
01418     }
01419     if (this->upperLimit < parameter) {
01420       throw std::out_of_range("The parameter exceeds the upper limit");
01421     }
01422 
01423     this->value = parameter;
01424   // Bouml preserved body end 000B4EF1
01425 }
01426 
01427 void PulseDivisor::toString(std::string& value) const {
01428   // Bouml preserved body begin 000B4F71
01429   std::stringstream ss;
01430   ss << this->name << ": " << this->value;
01431   value  = ss.str();
01432   // Bouml preserved body end 000B4F71
01433 }
01434 
01435 void PulseDivisor::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
01436   // Bouml preserved body begin 000B4FF1
01437     message.stctOutput.typeNumber = 154;  //PulseDivisor
01438     message.stctOutput.value = value;
01439   // Bouml preserved body end 000B4FF1
01440 }
01441 
01442 void PulseDivisor::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
01443   // Bouml preserved body begin 000B5071
01444     this->value = message.stctInput.value;
01445   // Bouml preserved body end 000B5071
01446 }
01447 
01448 RampDivisor::RampDivisor() {
01449   // Bouml preserved body begin 000B48F1
01450     this->name = "RampDivisor";
01451     this->lowerLimit = 0;
01452     this->upperLimit = 13;
01453     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
01454   // Bouml preserved body end 000B48F1
01455 }
01456 
01457 RampDivisor::~RampDivisor() {
01458   // Bouml preserved body begin 000B4971
01459   // Bouml preserved body end 000B4971
01460 }
01461 
01462 void RampDivisor::getParameter(unsigned int& parameter) const {
01463   // Bouml preserved body begin 000B49F1
01464     parameter = this->value;
01465   // Bouml preserved body end 000B49F1
01466 }
01467 
01468 void RampDivisor::setParameter(const unsigned int& parameter) {
01469   // Bouml preserved body begin 000B4A71
01470     if (this->lowerLimit > parameter) {
01471       throw std::out_of_range("The parameter exceeds the lower limit");
01472     }
01473     if (this->upperLimit < parameter) {
01474       throw std::out_of_range("The parameter exceeds the upper limit");
01475     }
01476 
01477     this->value = parameter;
01478   // Bouml preserved body end 000B4A71
01479 }
01480 
01481 void RampDivisor::toString(std::string& value) const {
01482   // Bouml preserved body begin 000B4AF1
01483   std::stringstream ss;
01484   ss << this->name << ": " << this->value;
01485   value  = ss.str();
01486   // Bouml preserved body end 000B4AF1
01487 }
01488 
01489 void RampDivisor::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
01490   // Bouml preserved body begin 000B4B71
01491     message.stctOutput.typeNumber = 153;  //RampDivisor
01492     message.stctOutput.value = value;
01493   // Bouml preserved body end 000B4B71
01494 }
01495 
01496 void RampDivisor::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
01497   // Bouml preserved body begin 000B4BF1
01498     this->value = message.stctInput.value;
01499   // Bouml preserved body end 000B4BF1
01500 }
01501 
01502 RampMode::RampMode() {
01503   // Bouml preserved body begin 000B3FF1
01504     this->name = "RampMode";
01505     this->lowerLimit = 0;
01506     this->upperLimit = 2;
01507     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
01508   // Bouml preserved body end 000B3FF1
01509 }
01510 
01511 RampMode::~RampMode() {
01512   // Bouml preserved body begin 000B4071
01513   // Bouml preserved body end 000B4071
01514 }
01515 
01516 void RampMode::getParameter(unsigned int& parameter) const {
01517   // Bouml preserved body begin 000B40F1
01518     parameter = this->value;
01519   // Bouml preserved body end 000B40F1
01520 }
01521 
01522 void RampMode::setParameter(const unsigned int& parameter) {
01523   // Bouml preserved body begin 000B4171
01524     if (this->lowerLimit > parameter) {
01525       throw std::out_of_range("The parameter exceeds the lower limit");
01526     }
01527     if (this->upperLimit < parameter) {
01528       throw std::out_of_range("The parameter exceeds the upper limit");
01529     }
01530 
01531     this->value = parameter;
01532   // Bouml preserved body end 000B4171
01533 }
01534 
01535 void RampMode::toString(std::string& value) const {
01536   // Bouml preserved body begin 000B41F1
01537   std::stringstream ss;
01538   ss << this->name << ": " << this->value;
01539   value  = ss.str();
01540   // Bouml preserved body end 000B41F1
01541 }
01542 
01543 void RampMode::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
01544   // Bouml preserved body begin 000B4271
01545     message.stctOutput.typeNumber = 138;  //RampMode
01546     message.stctOutput.value = value;
01547   // Bouml preserved body end 000B4271
01548 }
01549 
01550 void RampMode::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
01551   // Bouml preserved body begin 000B42F1
01552     this->value = message.stctInput.value;
01553   // Bouml preserved body end 000B42F1
01554 }
01555 
01556 ShortDetectionTimer::ShortDetectionTimer() {
01557   // Bouml preserved body begin 000B9E71
01558     this->name = "ShortDetectionTimer";
01559     this->lowerLimit = 0;
01560     this->upperLimit = 3;
01561     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
01562   // Bouml preserved body end 000B9E71
01563 }
01564 
01565 ShortDetectionTimer::~ShortDetectionTimer() {
01566   // Bouml preserved body begin 000B9EF1
01567   // Bouml preserved body end 000B9EF1
01568 }
01569 
01570 void ShortDetectionTimer::getParameter(unsigned int& parameter) const {
01571   // Bouml preserved body begin 000B9F71
01572     parameter = this->value;
01573   // Bouml preserved body end 000B9F71
01574 }
01575 
01576 void ShortDetectionTimer::setParameter(const unsigned int& parameter) {
01577   // Bouml preserved body begin 000B9FF1
01578     if (this->lowerLimit > parameter) {
01579       throw std::out_of_range("The parameter exceeds the lower limit");
01580     }
01581     if (this->upperLimit < parameter) {
01582       throw std::out_of_range("The parameter exceeds the upper limit");
01583     }
01584 
01585     this->value = parameter;
01586   // Bouml preserved body end 000B9FF1
01587 }
01588 
01589 void ShortDetectionTimer::toString(std::string& value) const {
01590   // Bouml preserved body begin 000BA071
01591   std::stringstream ss;
01592   ss << this->name << ": " << this->value;
01593   value  = ss.str();
01594   // Bouml preserved body end 000BA071
01595 }
01596 
01597 void ShortDetectionTimer::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
01598   // Bouml preserved body begin 000BA0F1
01599     message.stctOutput.typeNumber = 178;  //ShortDetectionTimer
01600     message.stctOutput.value = value;
01601   // Bouml preserved body end 000BA0F1
01602 }
01603 
01604 void ShortDetectionTimer::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
01605   // Bouml preserved body begin 000BA171
01606     this->value = message.stctInput.value;
01607   // Bouml preserved body end 000BA171
01608 }
01609 
01610 ShortProtectionDisable::ShortProtectionDisable() {
01611   // Bouml preserved body begin 000B99F1
01612     this->name = "ShortProtectionDisable";
01613     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
01614   // Bouml preserved body end 000B99F1
01615 }
01616 
01617 ShortProtectionDisable::~ShortProtectionDisable() {
01618   // Bouml preserved body begin 000B9A71
01619   // Bouml preserved body end 000B9A71
01620 }
01621 
01622 void ShortProtectionDisable::getParameter(bool& parameter) const {
01623   // Bouml preserved body begin 000B9AF1
01624     parameter = this->value;
01625   // Bouml preserved body end 000B9AF1
01626 }
01627 
01628 void ShortProtectionDisable::setParameter(const bool parameter) {
01629   // Bouml preserved body begin 000B9B71
01630     this->value = parameter;
01631   // Bouml preserved body end 000B9B71
01632 }
01633 
01634 void ShortProtectionDisable::toString(std::string& value) const {
01635   // Bouml preserved body begin 000B9BF1
01636   std::stringstream ss;
01637   ss << this->name << ": " << this->value;
01638   value  = ss.str();
01639   // Bouml preserved body end 000B9BF1
01640 }
01641 
01642 void ShortProtectionDisable::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
01643   // Bouml preserved body begin 000B9C71
01644     message.stctOutput.typeNumber = 177;  //ShortProtectionDisable
01645     message.stctOutput.value = value;
01646   // Bouml preserved body end 000B9C71
01647 }
01648 
01649 void ShortProtectionDisable::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
01650   // Bouml preserved body begin 000B9CF1
01651     this->value = message.stctInput.value;
01652   // Bouml preserved body end 000B9CF1
01653 }
01654 
01655 SlopeControlHighSide::SlopeControlHighSide() {
01656   // Bouml preserved body begin 000B90F1
01657     this->name = "SlopeControlHighSide";
01658     this->lowerLimit = 0;
01659     this->upperLimit = 3;
01660     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
01661   // Bouml preserved body end 000B90F1
01662 }
01663 
01664 SlopeControlHighSide::~SlopeControlHighSide() {
01665   // Bouml preserved body begin 000B9171
01666   // Bouml preserved body end 000B9171
01667 }
01668 
01669 void SlopeControlHighSide::getParameter(unsigned int& parameter) const {
01670   // Bouml preserved body begin 000B91F1
01671     parameter = this->value;
01672   // Bouml preserved body end 000B91F1
01673 }
01674 
01675 void SlopeControlHighSide::setParameter(const unsigned int& parameter) {
01676   // Bouml preserved body begin 000B9271
01677     if (this->lowerLimit > parameter) {
01678       throw std::out_of_range("The parameter exceeds the lower limit");
01679     }
01680     if (this->upperLimit < parameter) {
01681       throw std::out_of_range("The parameter exceeds the upper limit");
01682     }
01683 
01684     this->value = parameter;
01685   // Bouml preserved body end 000B9271
01686 }
01687 
01688 void SlopeControlHighSide::toString(std::string& value) const {
01689   // Bouml preserved body begin 000B92F1
01690   std::stringstream ss;
01691   ss << this->name << ": " << this->value;
01692   value  = ss.str();
01693   // Bouml preserved body end 000B92F1
01694 }
01695 
01696 void SlopeControlHighSide::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
01697   // Bouml preserved body begin 000B9371
01698     message.stctOutput.typeNumber = 175;  //SlopeControlHighSide
01699     message.stctOutput.value = value;
01700   // Bouml preserved body end 000B9371
01701 }
01702 
01703 void SlopeControlHighSide::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
01704   // Bouml preserved body begin 000B93F1
01705     this->value = message.stctInput.value;
01706   // Bouml preserved body end 000B93F1
01707 }
01708 
01709 SlopeControlLowSide::SlopeControlLowSide() {
01710   // Bouml preserved body begin 000B9571
01711     this->name = "SlopeControlLowSide";
01712     this->lowerLimit = 0;
01713     this->upperLimit = 3;
01714     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
01715   // Bouml preserved body end 000B9571
01716 }
01717 
01718 SlopeControlLowSide::~SlopeControlLowSide() {
01719   // Bouml preserved body begin 000B95F1
01720   // Bouml preserved body end 000B95F1
01721 }
01722 
01723 void SlopeControlLowSide::getParameter(unsigned int& parameter) const {
01724   // Bouml preserved body begin 000B9671
01725     parameter = this->value;
01726   // Bouml preserved body end 000B9671
01727 }
01728 
01729 void SlopeControlLowSide::setParameter(const unsigned int& parameter) {
01730   // Bouml preserved body begin 000B96F1
01731     if (this->lowerLimit > parameter) {
01732       throw std::out_of_range("The parameter exceeds the lower limit");
01733     }
01734     if (this->upperLimit < parameter) {
01735       throw std::out_of_range("The parameter exceeds the upper limit");
01736     }
01737 
01738     this->value = parameter;
01739   // Bouml preserved body end 000B96F1
01740 }
01741 
01742 void SlopeControlLowSide::toString(std::string& value) const {
01743   // Bouml preserved body begin 000B9771
01744   std::stringstream ss;
01745   ss << this->name << ": " << this->value;
01746   value  = ss.str();
01747   // Bouml preserved body end 000B9771
01748 }
01749 
01750 void SlopeControlLowSide::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
01751   // Bouml preserved body begin 000B97F1
01752     message.stctOutput.typeNumber = 176;  //SlopeControlLowSide
01753     message.stctOutput.value = value;
01754   // Bouml preserved body end 000B97F1
01755 }
01756 
01757 void SlopeControlLowSide::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
01758   // Bouml preserved body begin 000B9871
01759     this->value = message.stctInput.value;
01760   // Bouml preserved body end 000B9871
01761 }
01762 
01763 SmartEnergyActualCurrent::SmartEnergyActualCurrent() {
01764   // Bouml preserved body begin 000BA771
01765     this->name = "SmartEnergyActualCurrent";
01766     this->lowerLimit = 0;
01767     this->upperLimit = 31;
01768     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
01769   // Bouml preserved body end 000BA771
01770 }
01771 
01772 SmartEnergyActualCurrent::~SmartEnergyActualCurrent() {
01773   // Bouml preserved body begin 000BA7F1
01774   // Bouml preserved body end 000BA7F1
01775 }
01776 
01777 void SmartEnergyActualCurrent::getParameter(unsigned int& parameter) const {
01778   // Bouml preserved body begin 000BA871
01779     parameter = this->value;
01780   // Bouml preserved body end 000BA871
01781 }
01782 
01783 void SmartEnergyActualCurrent::setParameter(const unsigned int& parameter) {
01784   // Bouml preserved body begin 000BA8F1
01785     if (this->lowerLimit > parameter) {
01786       throw std::out_of_range("The parameter exceeds the lower limit");
01787     }
01788     if (this->upperLimit < parameter) {
01789       throw std::out_of_range("The parameter exceeds the upper limit");
01790     }
01791 
01792     this->value = parameter;
01793   // Bouml preserved body end 000BA8F1
01794 }
01795 
01796 void SmartEnergyActualCurrent::toString(std::string& value) const {
01797   // Bouml preserved body begin 000BA971
01798   std::stringstream ss;
01799   ss << this->name << ": " << this->value;
01800   value  = ss.str();
01801   // Bouml preserved body end 000BA971
01802 }
01803 
01804 void SmartEnergyActualCurrent::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
01805   // Bouml preserved body begin 000BA9F1
01806     message.stctOutput.typeNumber = 180;   //SmartEnergyActualCurrent
01807     message.stctOutput.value = value;
01808   // Bouml preserved body end 000BA9F1
01809 }
01810 
01811 void SmartEnergyActualCurrent::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
01812   // Bouml preserved body begin 000BAA71
01813     this->value = message.stctInput.value;
01814   // Bouml preserved body end 000BAA71
01815 }
01816 
01817 SmartEnergyCurrentDownStep::SmartEnergyCurrentDownStep() {
01818   // Bouml preserved body begin 000B75F1
01819     this->name = "SmartEnergyCurrentDownStep";
01820     this->lowerLimit = 0;
01821     this->upperLimit = 3;
01822     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
01823   // Bouml preserved body end 000B75F1
01824 }
01825 
01826 SmartEnergyCurrentDownStep::~SmartEnergyCurrentDownStep() {
01827   // Bouml preserved body begin 000B7671
01828   // Bouml preserved body end 000B7671
01829 }
01830 
01831 void SmartEnergyCurrentDownStep::getParameter(unsigned int& parameter) const {
01832   // Bouml preserved body begin 000B76F1
01833     parameter = this->value;
01834   // Bouml preserved body end 000B76F1
01835 }
01836 
01837 void SmartEnergyCurrentDownStep::setParameter(const unsigned int& parameter) {
01838   // Bouml preserved body begin 000B7771
01839     if (this->lowerLimit > parameter) {
01840       throw std::out_of_range("The parameter exceeds the lower limit");
01841     }
01842     if (this->upperLimit < parameter) {
01843       throw std::out_of_range("The parameter exceeds the upper limit");
01844     }
01845 
01846     this->value = parameter;
01847   // Bouml preserved body end 000B7771
01848 }
01849 
01850 void SmartEnergyCurrentDownStep::toString(std::string& value) const {
01851   // Bouml preserved body begin 000B77F1
01852   std::stringstream ss;
01853   ss << this->name << ": " << this->value;
01854   value  = ss.str();
01855   // Bouml preserved body end 000B77F1
01856 }
01857 
01858 void SmartEnergyCurrentDownStep::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
01859   // Bouml preserved body begin 000B7871
01860     message.stctOutput.typeNumber = 169;   //SmartEnergyCurrentDownStep
01861     message.stctOutput.value = value;
01862   // Bouml preserved body end 000B7871
01863 }
01864 
01865 void SmartEnergyCurrentDownStep::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
01866   // Bouml preserved body begin 000B78F1
01867     this->value = message.stctInput.value;
01868   // Bouml preserved body end 000B78F1
01869 }
01870 
01871 SmartEnergyCurrentMinimum::SmartEnergyCurrentMinimum() {
01872   // Bouml preserved body begin 000B7171
01873     this->name = "SmartEnergyCurrentMinimum";
01874     this->lowerLimit = 0;
01875     this->upperLimit = 1;
01876     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
01877   // Bouml preserved body end 000B7171
01878 }
01879 
01880 SmartEnergyCurrentMinimum::~SmartEnergyCurrentMinimum() {
01881   // Bouml preserved body begin 000B71F1
01882   // Bouml preserved body end 000B71F1
01883 }
01884 
01885 void SmartEnergyCurrentMinimum::getParameter(unsigned int& parameter) const {
01886   // Bouml preserved body begin 000B7271
01887     parameter = this->value;
01888   // Bouml preserved body end 000B7271
01889 }
01890 
01891 void SmartEnergyCurrentMinimum::setParameter(const unsigned int& parameter) {
01892   // Bouml preserved body begin 000B72F1
01893     if (this->lowerLimit > parameter) {
01894       throw std::out_of_range("The parameter exceeds the lower limit");
01895     }
01896     if (this->upperLimit < parameter) {
01897       throw std::out_of_range("The parameter exceeds the upper limit");
01898     }
01899 
01900     this->value = parameter;
01901   // Bouml preserved body end 000B72F1
01902 }
01903 
01904 void SmartEnergyCurrentMinimum::toString(std::string& value) const {
01905   // Bouml preserved body begin 000B7371
01906   std::stringstream ss;
01907   ss << this->name << ": " << this->value;
01908   value  = ss.str();
01909   // Bouml preserved body end 000B7371
01910 }
01911 
01912 void SmartEnergyCurrentMinimum::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
01913   // Bouml preserved body begin 000B73F1
01914     message.stctOutput.typeNumber = 168;  //SmartEnergyCurrentMinimum
01915     message.stctOutput.value = value;
01916   // Bouml preserved body end 000B73F1
01917 }
01918 
01919 void SmartEnergyCurrentMinimum::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
01920   // Bouml preserved body begin 000B7471
01921     this->value = message.stctInput.value;
01922   // Bouml preserved body end 000B7471
01923 }
01924 
01925 SmartEnergyCurrentUpStep::SmartEnergyCurrentUpStep() {
01926   // Bouml preserved body begin 000B7EF1
01927     this->name = "SmartEnergyCurrentUpStep";
01928     this->lowerLimit = 1;
01929     this->upperLimit = 3;
01930     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
01931   // Bouml preserved body end 000B7EF1
01932 }
01933 
01934 SmartEnergyCurrentUpStep::~SmartEnergyCurrentUpStep() {
01935   // Bouml preserved body begin 000B7F71
01936   // Bouml preserved body end 000B7F71
01937 }
01938 
01939 void SmartEnergyCurrentUpStep::getParameter(unsigned int& parameter) const {
01940   // Bouml preserved body begin 000B7FF1
01941     parameter = this->value;
01942   // Bouml preserved body end 000B7FF1
01943 }
01944 
01945 void SmartEnergyCurrentUpStep::setParameter(const unsigned int& parameter) {
01946   // Bouml preserved body begin 000B8071
01947     if (this->lowerLimit > parameter) {
01948       throw std::out_of_range("The parameter exceeds the lower limit");
01949     }
01950     if (this->upperLimit < parameter) {
01951       throw std::out_of_range("The parameter exceeds the upper limit");
01952     }
01953 
01954     this->value = parameter;
01955   // Bouml preserved body end 000B8071
01956 }
01957 
01958 void SmartEnergyCurrentUpStep::toString(std::string& value) const {
01959   // Bouml preserved body begin 000B80F1
01960   std::stringstream ss;
01961   ss << this->name << ": " << this->value;
01962   value  = ss.str();
01963   // Bouml preserved body end 000B80F1
01964 }
01965 
01966 void SmartEnergyCurrentUpStep::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
01967   // Bouml preserved body begin 000B8171
01968     message.stctOutput.typeNumber = 171;   //SmartEnergyCurrentUpStep
01969     message.stctOutput.value = value;
01970   // Bouml preserved body end 000B8171
01971 }
01972 
01973 void SmartEnergyCurrentUpStep::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
01974   // Bouml preserved body begin 000B81F1
01975     this->value = message.stctInput.value;
01976   // Bouml preserved body end 000B81F1
01977 }
01978 
01979 SmartEnergyHysteresis::SmartEnergyHysteresis() {
01980   // Bouml preserved body begin 000B7A71
01981     this->name = "SmartEnergyHysteresis";
01982     this->lowerLimit = 0;
01983     this->upperLimit = 15;
01984     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
01985   // Bouml preserved body end 000B7A71
01986 }
01987 
01988 SmartEnergyHysteresis::~SmartEnergyHysteresis() {
01989   // Bouml preserved body begin 000B7AF1
01990   // Bouml preserved body end 000B7AF1
01991 }
01992 
01993 void SmartEnergyHysteresis::getParameter(unsigned int& parameter) const {
01994   // Bouml preserved body begin 000B7B71
01995     parameter = this->value;
01996   // Bouml preserved body end 000B7B71
01997 }
01998 
01999 void SmartEnergyHysteresis::setParameter(const unsigned int& parameter) {
02000   // Bouml preserved body begin 000B7BF1
02001     if (this->lowerLimit > parameter) {
02002       throw std::out_of_range("The parameter exceeds the lower limit");
02003     }
02004     if (this->upperLimit < parameter) {
02005       throw std::out_of_range("The parameter exceeds the upper limit");
02006     }
02007 
02008     this->value = parameter;
02009   // Bouml preserved body end 000B7BF1
02010 }
02011 
02012 void SmartEnergyHysteresis::toString(std::string& value) const {
02013   // Bouml preserved body begin 000B7C71
02014   std::stringstream ss;
02015   ss << this->name << ": " << this->value;
02016   value  = ss.str();
02017   // Bouml preserved body end 000B7C71
02018 }
02019 
02020 void SmartEnergyHysteresis::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
02021   // Bouml preserved body begin 000B7CF1
02022     message.stctOutput.typeNumber = 170;   //SmartEnergyHysteresis
02023     message.stctOutput.value = value;
02024   // Bouml preserved body end 000B7CF1
02025 }
02026 
02027 void SmartEnergyHysteresis::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
02028   // Bouml preserved body begin 000B7D71
02029     this->value = message.stctInput.value;
02030   // Bouml preserved body end 000B7D71
02031 }
02032 
02033 SmartEnergyHysteresisStart::SmartEnergyHysteresisStart() {
02034   // Bouml preserved body begin 000B8371
02035     this->name = "SmartEnergyHysteresisStart";
02036     this->lowerLimit = 0;
02037     this->upperLimit = 15;
02038     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
02039   // Bouml preserved body end 000B8371
02040 }
02041 
02042 SmartEnergyHysteresisStart::~SmartEnergyHysteresisStart() {
02043   // Bouml preserved body begin 000B83F1
02044   // Bouml preserved body end 000B83F1
02045 }
02046 
02047 void SmartEnergyHysteresisStart::getParameter(unsigned int& parameter) const {
02048   // Bouml preserved body begin 000B8471
02049     parameter = this->value;
02050   // Bouml preserved body end 000B8471
02051 }
02052 
02053 void SmartEnergyHysteresisStart::setParameter(const unsigned int& parameter) {
02054   // Bouml preserved body begin 000B84F1
02055     if (this->lowerLimit > parameter) {
02056       throw std::out_of_range("The parameter exceeds the lower limit");
02057     }
02058     if (this->upperLimit < parameter) {
02059       throw std::out_of_range("The parameter exceeds the upper limit");
02060     }
02061 
02062     this->value = parameter;
02063   // Bouml preserved body end 000B84F1
02064 }
02065 
02066 void SmartEnergyHysteresisStart::toString(std::string& value) const {
02067   // Bouml preserved body begin 000B8571
02068   std::stringstream ss;
02069   ss << this->name << ": " << this->value;
02070   value  = ss.str();
02071   // Bouml preserved body end 000B8571
02072 }
02073 
02074 void SmartEnergyHysteresisStart::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
02075   // Bouml preserved body begin 000B85F1
02076     message.stctOutput.typeNumber = 172;  //SmartEnergyHysteresisStart
02077     message.stctOutput.value = value;
02078   // Bouml preserved body end 000B85F1
02079 }
02080 
02081 void SmartEnergyHysteresisStart::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
02082   // Bouml preserved body begin 000B8671
02083     this->value = message.stctInput.value;
02084   // Bouml preserved body end 000B8671
02085 }
02086 
02087 SmartEnergySlowRunCurrent::SmartEnergySlowRunCurrent() {
02088   // Bouml preserved body begin 000BB4F1
02089     this->name = "SmartEnergySlowRunCurrent";
02090     this->lowerLimit = 0;
02091     this->upperLimit = 255;
02092     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
02093   // Bouml preserved body end 000BB4F1
02094 }
02095 
02096 SmartEnergySlowRunCurrent::~SmartEnergySlowRunCurrent() {
02097   // Bouml preserved body begin 000BB571
02098   // Bouml preserved body end 000BB571
02099 }
02100 
02101 void SmartEnergySlowRunCurrent::getParameter(unsigned int& parameter) const {
02102   // Bouml preserved body begin 000BB5F1
02103     parameter = this->value;
02104   // Bouml preserved body end 000BB5F1
02105 }
02106 
02107 void SmartEnergySlowRunCurrent::setParameter(const unsigned int& parameter) {
02108   // Bouml preserved body begin 000BB671
02109     if (this->lowerLimit > parameter) {
02110       throw std::out_of_range("The parameter exceeds the lower limit");
02111     }
02112     if (this->upperLimit < parameter) {
02113       throw std::out_of_range("The parameter exceeds the upper limit");
02114     }
02115 
02116     this->value = parameter;
02117   // Bouml preserved body end 000BB671
02118 }
02119 
02120 void SmartEnergySlowRunCurrent::toString(std::string& value) const {
02121   // Bouml preserved body begin 000BB6F1
02122   std::stringstream ss;
02123   ss << this->name << ": " << this->value;
02124   value  = ss.str();
02125   // Bouml preserved body end 000BB6F1
02126 }
02127 
02128 void SmartEnergySlowRunCurrent::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
02129   // Bouml preserved body begin 000BB771
02130     message.stctOutput.typeNumber = 183;   //SmartEnergySlowRunCurrent
02131     message.stctOutput.value = value;
02132   // Bouml preserved body end 000BB771
02133 }
02134 
02135 void SmartEnergySlowRunCurrent::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
02136   // Bouml preserved body begin 000BB7F1
02137     this->value = message.stctInput.value;
02138   // Bouml preserved body end 000BB7F1
02139 }
02140 
02141 SmartEnergyThresholdSpeed::SmartEnergyThresholdSpeed() {
02142   // Bouml preserved body begin 000BB071
02143     this->name = "SmartEnergyThresholdSpeed";
02144     this->lowerLimit = 0;
02145     this->upperLimit = 2047;
02146     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
02147   // Bouml preserved body end 000BB071
02148 }
02149 
02150 SmartEnergyThresholdSpeed::~SmartEnergyThresholdSpeed() {
02151   // Bouml preserved body begin 000BB0F1
02152   // Bouml preserved body end 000BB0F1
02153 }
02154 
02155 void SmartEnergyThresholdSpeed::getParameter(unsigned int& parameter) const {
02156   // Bouml preserved body begin 000BB171
02157     parameter = this->value;
02158   // Bouml preserved body end 000BB171
02159 }
02160 
02161 void SmartEnergyThresholdSpeed::setParameter(const unsigned int& parameter) {
02162   // Bouml preserved body begin 000BB1F1
02163     if (this->lowerLimit > parameter) {
02164       throw std::out_of_range("The parameter exceeds the lower limit");
02165     }
02166     if (this->upperLimit < parameter) {
02167       throw std::out_of_range("The parameter exceeds the upper limit");
02168     }
02169 
02170     this->value = parameter;
02171   // Bouml preserved body end 000BB1F1
02172 }
02173 
02174 void SmartEnergyThresholdSpeed::toString(std::string& value) const {
02175   // Bouml preserved body begin 000BB271
02176   std::stringstream ss;
02177   ss << this->name << ": " << this->value;
02178   value  = ss.str();
02179   // Bouml preserved body end 000BB271
02180 }
02181 
02182 void SmartEnergyThresholdSpeed::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
02183   // Bouml preserved body begin 000BB2F1
02184     message.stctOutput.typeNumber = 182;  //SmartEnergyThresholdSpeed
02185     message.stctOutput.value = value;
02186   // Bouml preserved body end 000BB2F1
02187 }
02188 
02189 void SmartEnergyThresholdSpeed::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
02190   // Bouml preserved body begin 000BB371
02191     this->value = message.stctInput.value;
02192   // Bouml preserved body end 000BB371
02193 }
02194 
02195 StallGuard2FilterEnable::StallGuard2FilterEnable() {
02196   // Bouml preserved body begin 000B87F1
02197     this->name = "StallGuard2FilterEnable";
02198     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
02199   // Bouml preserved body end 000B87F1
02200 }
02201 
02202 StallGuard2FilterEnable::~StallGuard2FilterEnable() {
02203   // Bouml preserved body begin 000B8871
02204   // Bouml preserved body end 000B8871
02205 }
02206 
02207 void StallGuard2FilterEnable::getParameter(bool& parameter) const {
02208   // Bouml preserved body begin 000B88F1
02209     parameter = this->value;
02210   // Bouml preserved body end 000B88F1
02211 }
02212 
02213 void StallGuard2FilterEnable::setParameter(const bool parameter) {
02214   // Bouml preserved body begin 000B8971
02215     this->value = parameter;
02216   // Bouml preserved body end 000B8971
02217 }
02218 
02219 void StallGuard2FilterEnable::toString(std::string& value) const {
02220   // Bouml preserved body begin 000B89F1
02221   std::stringstream ss;
02222   ss << this->name << ": " << this->value;
02223   value  = ss.str();
02224   // Bouml preserved body end 000B89F1
02225 }
02226 
02227 void StallGuard2FilterEnable::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
02228   // Bouml preserved body begin 000B8A71
02229     message.stctOutput.typeNumber = 173;  //StallGuard2FilterEnable
02230     message.stctOutput.value = value;
02231   // Bouml preserved body end 000B8A71
02232 }
02233 
02234 void StallGuard2FilterEnable::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
02235   // Bouml preserved body begin 000B8AF1
02236     this->value = message.stctInput.value;
02237   // Bouml preserved body end 000B8AF1
02238 }
02239 
02240 StallGuard2Threshold::StallGuard2Threshold() {
02241   // Bouml preserved body begin 000B8C71
02242     this->name = "StallGuard2Threshold";
02243     this->lowerLimit = -64;
02244     this->upperLimit = 63;
02245     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
02246   // Bouml preserved body end 000B8C71
02247 }
02248 
02249 StallGuard2Threshold::~StallGuard2Threshold() {
02250   // Bouml preserved body begin 000B8CF1
02251   // Bouml preserved body end 000B8CF1
02252 }
02253 
02254 void StallGuard2Threshold::getParameter(int& parameter) const {
02255   // Bouml preserved body begin 000B8D71
02256     parameter = this->value;
02257   // Bouml preserved body end 000B8D71
02258 }
02259 
02260 void StallGuard2Threshold::setParameter(const int parameter) {
02261   // Bouml preserved body begin 000B8DF1
02262     if (this->lowerLimit > parameter) {
02263       throw std::out_of_range("The parameter exceeds the lower limit");
02264     }
02265     if (this->upperLimit < parameter) {
02266       throw std::out_of_range("The parameter exceeds the upper limit");
02267     }
02268 
02269     this->value = parameter;
02270   // Bouml preserved body end 000B8DF1
02271 }
02272 
02273 void StallGuard2Threshold::toString(std::string& value) const {
02274   // Bouml preserved body begin 000B8E71
02275   std::stringstream ss;
02276   ss << this->name << ": " << this->value;
02277   value  = ss.str();
02278   // Bouml preserved body end 000B8E71
02279 }
02280 
02281 void StallGuard2Threshold::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
02282   // Bouml preserved body begin 000B8EF1
02283     message.stctOutput.typeNumber = 174;  //StallGuard2Threshold
02284     message.stctOutput.value = value;
02285   // Bouml preserved body end 000B8EF1
02286 }
02287 
02288 void StallGuard2Threshold::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
02289   // Bouml preserved body begin 000B8F71
02290     this->value = (int32)message.stctInput.value;
02291   // Bouml preserved body end 000B8F71
02292 }
02293 
02294 StandbyCurrent::StandbyCurrent() {
02295   // Bouml preserved body begin 000B3B71
02296     this->name = "StandbyCurrent";
02297     this->lowerLimit = 0;
02298     this->upperLimit = 255;
02299     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
02300   // Bouml preserved body end 000B3B71
02301 }
02302 
02303 StandbyCurrent::~StandbyCurrent() {
02304   // Bouml preserved body begin 000B3BF1
02305   // Bouml preserved body end 000B3BF1
02306 }
02307 
02308 void StandbyCurrent::getParameter(int& parameter) const {
02309   // Bouml preserved body begin 000B3C71
02310     parameter = this->value;
02311   // Bouml preserved body end 000B3C71
02312 }
02313 
02314 void StandbyCurrent::setParameter(const int parameter) {
02315   // Bouml preserved body begin 000B3CF1
02316     if (this->lowerLimit > parameter) {
02317       throw std::out_of_range("The parameter exceeds the lower limit");
02318     }
02319     if (this->upperLimit < parameter) {
02320       throw std::out_of_range("The parameter exceeds the upper limit");
02321     }
02322 
02323     this->value = parameter;
02324   // Bouml preserved body end 000B3CF1
02325 }
02326 
02327 void StandbyCurrent::toString(std::string& value) const {
02328   // Bouml preserved body begin 000B3D71
02329   std::stringstream ss;
02330   ss << this->name << ": " << this->value;
02331   value  = ss.str();
02332   // Bouml preserved body end 000B3D71
02333 }
02334 
02335 void StandbyCurrent::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
02336   // Bouml preserved body begin 000B3DF1
02337     message.stctOutput.typeNumber = 7;  //StandbyCurrent
02338     message.stctOutput.value = value;
02339   // Bouml preserved body end 000B3DF1
02340 }
02341 
02342 void StandbyCurrent::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
02343   // Bouml preserved body begin 000B3E71
02344     this->value = message.stctInput.value;
02345   // Bouml preserved body end 000B3E71
02346 }
02347 
02348 StepInterpolationEnable::StepInterpolationEnable() {
02349   // Bouml preserved body begin 000B51F1
02350     this->name = "StepInterpolationEnable";
02351     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
02352   // Bouml preserved body end 000B51F1
02353 }
02354 
02355 StepInterpolationEnable::~StepInterpolationEnable() {
02356   // Bouml preserved body begin 000B5271
02357   // Bouml preserved body end 000B5271
02358 }
02359 
02360 void StepInterpolationEnable::getParameter(bool& parameter) const {
02361   // Bouml preserved body begin 000B52F1
02362     parameter = this->value;
02363   // Bouml preserved body end 000B52F1
02364 }
02365 
02366 void StepInterpolationEnable::setParameter(const bool parameter) {
02367   // Bouml preserved body begin 000B5371
02368     this->value = parameter;
02369   // Bouml preserved body end 000B5371
02370 }
02371 
02372 void StepInterpolationEnable::toString(std::string& value) const {
02373   // Bouml preserved body begin 000B53F1
02374   std::stringstream ss;
02375   ss << this->name << ": " << this->value;
02376   value  = ss.str();
02377   // Bouml preserved body end 000B53F1
02378 }
02379 
02380 void StepInterpolationEnable::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
02381   // Bouml preserved body begin 000B5471
02382     message.stctOutput.typeNumber = 160;  //StepInterpolationEnable
02383     message.stctOutput.value = value;
02384   // Bouml preserved body end 000B5471
02385 }
02386 
02387 void StepInterpolationEnable::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
02388   // Bouml preserved body begin 000B54F1
02389     this->value = message.stctInput.value;
02390   // Bouml preserved body end 000B54F1
02391 }
02392 
02393 StopOnStall::StopOnStall() {
02394   // Bouml preserved body begin 000BABF1
02395     this->name = "StopOnStall";
02396     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
02397   // Bouml preserved body end 000BABF1
02398 }
02399 
02400 StopOnStall::~StopOnStall() {
02401   // Bouml preserved body begin 000BAC71
02402   // Bouml preserved body end 000BAC71
02403 }
02404 
02405 void StopOnStall::getParameter(bool& parameter) const {
02406   // Bouml preserved body begin 000BACF1
02407     parameter = this->value;
02408   // Bouml preserved body end 000BACF1
02409 }
02410 
02411 void StopOnStall::setParameter(const bool parameter) {
02412   // Bouml preserved body begin 000BAD71
02413     this->value = parameter;
02414   // Bouml preserved body end 000BAD71
02415 }
02416 
02417 void StopOnStall::toString(std::string& value) const {
02418   // Bouml preserved body begin 000BADF1
02419   std::stringstream ss;
02420   ss << this->name << ": " << this->value;
02421   value  = ss.str();
02422   // Bouml preserved body end 000BADF1
02423 }
02424 
02425 void StopOnStall::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
02426   // Bouml preserved body begin 000BAE71
02427     message.stctOutput.typeNumber = 181;  //StopOnStall
02428     if(value)
02429       message.stctOutput.value = 1;
02430     else
02431       message.stctOutput.value = 0;
02432 
02433   // Bouml preserved body end 000BAE71
02434 }
02435 
02436 void StopOnStall::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
02437   // Bouml preserved body begin 000BAEF1
02438     this->value = message.stctInput.value;
02439   // Bouml preserved body end 000BAEF1
02440 }
02441 
02442 Vsense::Vsense() {
02443   // Bouml preserved body begin 000BA2F1
02444     this->name = "Vsense";
02445     this->lowerLimit = 0;
02446     this->upperLimit = 1;
02447     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
02448   // Bouml preserved body end 000BA2F1
02449 }
02450 
02451 Vsense::~Vsense() {
02452   // Bouml preserved body begin 000BA371
02453   // Bouml preserved body end 000BA371
02454 }
02455 
02456 void Vsense::getParameter(unsigned int& parameter) const {
02457   // Bouml preserved body begin 000BA3F1
02458     parameter = this->value;
02459   // Bouml preserved body end 000BA3F1
02460 }
02461 
02462 void Vsense::setParameter(const unsigned int& parameter) {
02463   // Bouml preserved body begin 000BA471
02464     if (this->lowerLimit > parameter) {
02465       throw std::out_of_range("The parameter exceeds the lower limit");
02466     }
02467     if (this->upperLimit < parameter) {
02468       throw std::out_of_range("The parameter exceeds the upper limit");
02469     }
02470 
02471     this->value = parameter;
02472   // Bouml preserved body end 000BA471
02473 }
02474 
02475 void Vsense::toString(std::string& value) const {
02476   // Bouml preserved body begin 000BA4F1
02477   std::stringstream ss;
02478   ss << this->name << ": " << this->value;
02479   value  = ss.str();
02480   // Bouml preserved body end 000BA4F1
02481 }
02482 
02483 void Vsense::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
02484   // Bouml preserved body begin 000BA571
02485     message.stctOutput.typeNumber = 179;  //Vsense
02486     message.stctOutput.value = value;
02487   // Bouml preserved body end 000BA571
02488 }
02489 
02490 void Vsense::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
02491   // Bouml preserved body begin 000BA5F1
02492     this->value = message.stctInput.value;
02493   // Bouml preserved body end 000BA5F1
02494 }
02495 
02496 ActualAcceleration::ActualAcceleration() {
02497   // Bouml preserved body begin 0010BBF1
02498     this->name = "ActualAcceleration";
02499     this->lowerLimit = 0;
02500     this->upperLimit = 2047;
02501     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
02502   // Bouml preserved body end 0010BBF1
02503 }
02504 
02505 ActualAcceleration::~ActualAcceleration() {
02506   // Bouml preserved body begin 0010BC71
02507   // Bouml preserved body end 0010BC71
02508 }
02509 
02510 void ActualAcceleration::getParameter(int& parameter) const {
02511   // Bouml preserved body begin 0010BCF1
02512     parameter = this->value;
02513   // Bouml preserved body end 0010BCF1
02514 }
02515 
02516 void ActualAcceleration::toString(std::string& value) const {
02517   // Bouml preserved body begin 0010BD71
02518   std::stringstream ss;
02519   ss << this->name << ": " << this->value;
02520   value  = ss.str();
02521   // Bouml preserved body end 0010BD71
02522 }
02523 
02524 void ActualAcceleration::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
02525   // Bouml preserved body begin 0010BDF1
02526     message.stctOutput.typeNumber = 135;  //ActualAcceleration
02527     message.stctOutput.value = value;
02528   // Bouml preserved body end 0010BDF1
02529 }
02530 
02531 void ActualAcceleration::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
02532   // Bouml preserved body begin 0010BE71
02533     this->value = message.stctInput.value;
02534   // Bouml preserved body end 0010BE71
02535 }
02536 
02537 MinimumSpeed::MinimumSpeed() {
02538   // Bouml preserved body begin 00107B71
02539     this->name = "MinimumSpeed";
02540     this->lowerLimit = 0;
02541     this->upperLimit = 2047;
02542     this->parameterType = MOTOR_CONTOLLER_PARAMETER;
02543   // Bouml preserved body end 00107B71
02544 }
02545 
02546 MinimumSpeed::~MinimumSpeed() {
02547   // Bouml preserved body begin 00107BF1
02548   // Bouml preserved body end 00107BF1
02549 }
02550 
02551 void MinimumSpeed::getParameter(int& parameter) const {
02552   // Bouml preserved body begin 00107C71
02553     parameter = this->value;
02554   // Bouml preserved body end 00107C71
02555 }
02556 
02557 void MinimumSpeed::setParameter(const int parameter) {
02558   // Bouml preserved body begin 00107CF1
02559     if (this->lowerLimit > parameter) {
02560       throw std::out_of_range("The parameter exceeds the lower limit");
02561     }
02562     if (this->upperLimit < parameter) {
02563       throw std::out_of_range("The parameter exceeds the upper limit");
02564     }
02565 
02566     this->value = parameter;
02567   // Bouml preserved body end 00107CF1
02568 }
02569 
02570 void MinimumSpeed::toString(std::string& value) const {
02571   // Bouml preserved body begin 00107D71
02572   std::stringstream ss;
02573   ss << this->name << ": " << this->value;
02574   value  = ss.str();
02575   // Bouml preserved body end 00107D71
02576 }
02577 
02578 void MinimumSpeed::getYouBotMailboxMsg(YouBotSlaveMailboxMsg& message) const {
02579   // Bouml preserved body begin 00107DF1
02580     message.stctOutput.typeNumber = 130;  //MinimumSpeed
02581     message.stctOutput.value = (uint32)value;
02582 
02583   // Bouml preserved body end 00107DF1
02584 }
02585 
02586 void MinimumSpeed::setYouBotMailboxMsg(const YouBotSlaveMailboxMsg& message) {
02587   // Bouml preserved body begin 00107E71
02588     this->value = (int32)message.stctInput.value;
02589   // Bouml preserved body end 00107E71
02590 }
02591 
02592 
02593 } // namespace youbot
Generated by  doxygen 1.6.3