ApplicationOutputs.cpp
Go to the documentation of this file.
1 // this is for emacs file handling -*- mode: c++; indent-tabs-mode: nil -*-
2 
3 // -- BEGIN LICENSE BLOCK ----------------------------------------------
4 
24 // -- END LICENSE BLOCK ------------------------------------------------
25 
26 //----------------------------------------------------------------------
33 //----------------------------------------------------------------------
34 
36 
37 namespace sick {
38 namespace datastructure {
39 
41 
42 std::vector<bool> ApplicationOutputs::getEvalOutVector() const
43 {
44  return m_eval_out_vector;
45 }
46 
47 void ApplicationOutputs::setEvalOutVector(const std::vector<bool>& eval_out_vector)
48 {
49  m_eval_out_vector = eval_out_vector;
50 }
51 
53 {
55 }
56 
57 void ApplicationOutputs::setEvalOutIsSafeVector(const std::vector<bool>& eval_out_is_safe_vector)
58 {
59  m_eval_out_is_safe_vector = eval_out_is_safe_vector;
60 }
61 
63 {
65 }
66 
67 void ApplicationOutputs::setEvalOutIsValidVector(const std::vector<bool>& eval_out_is_valid_vector)
68 {
69  m_eval_out_is_valid_vector = eval_out_is_valid_vector;
70 }
71 
72 std::vector<uint16_t> ApplicationOutputs::getMonitoringCaseVector() const
73 {
75 }
76 
78  const std::vector<uint16_t>& monitoring_case_vector)
79 {
80  m_monitoring_case_vector = monitoring_case_vector;
81 }
82 
84 {
86 }
87 
89  const std::vector<bool>& monitoring_case_flags_vector)
90 {
91  m_monitoring_case_flags_vector = monitoring_case_flags_vector;
92 }
93 
95 {
96  return m_sleep_mode_output;
97 }
98 
99 void ApplicationOutputs::setSleepModeOutput(const int8_t& sleep_mode_output)
100 {
101  m_sleep_mode_output = sleep_mode_output;
102 }
103 
105 {
107 }
108 
110  bool host_error_flag_contamination_warning)
111 {
112  m_host_error_flag_contamination_warning = host_error_flag_contamination_warning;
113 }
114 
116 {
118 }
119 
121  bool host_error_flag_contamination_error)
122 {
123  m_host_error_flag_contamination_error = host_error_flag_contamination_error;
124 }
125 
127 {
129 }
130 
131 void ApplicationOutputs::setHostErrorFlagManipulationError(bool host_error_flag_manipulation_error)
132 {
133  m_host_error_flag_manipulation_error = host_error_flag_manipulation_error;
134 }
135 
137 {
139 }
140 
141 void ApplicationOutputs::setHostErrorFlagGlare(bool host_error_flag_glare)
142 {
143  m_host_error_flag_glare = host_error_flag_glare;
144 }
145 
147 {
149 }
150 
152  bool host_error_flag_reference_contour_intruded)
153 {
154  m_host_error_flag_reference_contour_intruded = host_error_flag_reference_contour_intruded;
155 }
156 
158 {
160 }
161 
162 void ApplicationOutputs::setHostErrorFlagCriticalError(bool host_error_flag_critical_error)
163 {
164  m_host_error_flag_critical_error = host_error_flag_critical_error;
165 }
166 
168 {
169  return m_velocity_0;
170 }
171 
172 void ApplicationOutputs::setVelocity0(const int16_t& velocity_0)
173 {
174  m_velocity_0 = velocity_0;
175 }
176 
178 {
179  return m_velocity_1;
180 }
181 
182 void ApplicationOutputs::setVelocity1(const int16_t& velocity_1)
183 {
184  m_velocity_1 = velocity_1;
185 }
186 
188 {
189  return m_velocity_0_valid;
190 }
191 
192 void ApplicationOutputs::setVelocity0Valid(bool velocity_0_valid)
193 {
194  m_velocity_0_valid = velocity_0_valid;
195 }
196 
198 {
199  return m_velocity_1_valid;
200 }
201 
202 void ApplicationOutputs::setVelocity1Valid(bool velocity_1_valid)
203 {
204  m_velocity_1_valid = velocity_1_valid;
205 }
206 
208 {
210 }
211 
212 void ApplicationOutputs::setVelocity0TransmittedSafely(bool velocity_0_transmitted_safely)
213 {
214  m_velocity_0_transmitted_safely = velocity_0_transmitted_safely;
215 }
216 
218 {
220 }
221 
222 void ApplicationOutputs::setVelocity1TransmittedSafely(bool velocity_1_transmitted_safely)
223 {
224  m_velocity_1_transmitted_safely = velocity_1_transmitted_safely;
225 }
226 
228 {
230 }
231 
233  const std::vector<int16_t>& resulting_velocity_vector)
234 {
235  m_resulting_velocity_vector = resulting_velocity_vector;
236 }
237 
239 {
241 }
242 
244  const std::vector<bool>& resulting_velocity_is_valid_vector)
245 {
246  m_resulting_velocity_is_valid_vector = resulting_velocity_is_valid_vector;
247 }
248 
250 {
252 }
253 
254 void ApplicationOutputs::setFlagsSleepModeOutputIsValid(bool flags_sleep_mode_output_is_valid)
255 {
256  m_flags_sleep_mode_output_is_valid = flags_sleep_mode_output_is_valid;
257 }
258 
260 {
262 }
263 
264 void ApplicationOutputs::setFlagsHostErrorFlagsAreValid(bool flags_host_error_flags_are_valid)
265 {
266  m_flags_host_error_flags_are_valid = flags_host_error_flags_are_valid;
267 }
268 
269 } // namespace datastructure
270 } // namespace sick
bool getVelocity1TransmittedSafely() const
Gets if the second linear velocity output is transmitted safely.
void setVelocity1TransmittedSafely(bool velocity_1_transmitted_safely)
Sets if the second linear velocity output is transmitted safely.
int16_t getVelocity1() const
Gets the second linear velocity output.
void setHostErrorFlagGlare(bool host_error_flag_glare)
Sets if glare is present.
bool getHostErrorFlagReferenceContourIntruded() const
Gets if a reference contour is intruded.
bool getHostErrorFlagContaminationError() const
Gets if a contamination error is present.
void setResultingVelocityIsValidVector(const std::vector< bool > &resulting_velocity_is_valid_vector)
Sets if the resulting velocities are valid.
bool getFlagsSleepModeOutputIsValid() const
Gets if the sleep mode is valid.
std::vector< bool > getResultingVelocityIsValidVector() const
Gets if the resulting velocities are valid.
bool getHostErrorFlagGlare() const
Gets if glare is present.
std::vector< bool > getEvalOutIsSafeVector() const
Gets if a cut-off path from the output paths is safe.
void setResultingVelocityVector(const std::vector< int16_t > &resulting_velocity_vector)
Sets the resulting velocity for each monitoring case table.
void setVelocity0Valid(bool velocity_0_valid)
Sets if the first linear velocity output is valid.
std::vector< uint16_t > getMonitoringCaseVector() const
Gets the currently active monitoring case numbers.
void setMonitoringCaseVector(const std::vector< uint16_t > &monitoring_case_vector)
Sets the currently active monitoring case numbers.
void setVelocity1Valid(bool velocity_1_valid)
Sets if the second linear velocity output is valid.
int16_t getVelocity0() const
Gets the first linear velocity output.
std::vector< uint16_t > m_monitoring_case_vector
std::vector< int16_t > m_resulting_velocity_vector
void setSleepModeOutput(const int8_t &sleep_mode_output)
Sets the state of the sleep mode.
void setVelocity0(const int16_t &velocity_0)
Sets the first linear velocity output.
std::vector< bool > getEvalOutVector() const
Gets the state of the non safe cut-off paths.
void setHostErrorFlagReferenceContourIntruded(bool host_error_flag_reference_contour_intruded)
Sets if a reference contour is intruded.
void setVelocity0TransmittedSafely(bool velocity_0_transmitted_safely)
Sets if the first linear velocity output is transmitted safely.
bool getHostErrorFlagContaminationWarning() const
Gets if a contamination warning is present.
void setEvalOutIsValidVector(const std::vector< bool > &eval_out_is_valid_vector)
Sets if an output path is valid.
void setHostErrorFlagContaminationWarning(bool host_error_flag_contamination_warning)
Sets if a contamination warning is present.
bool getFlagsHostErrorFlagsAreValid() const
Gets if the error flags are valid.
void setHostErrorFlagCriticalError(bool host_error_flag_critical_error)
Sets if a critical error is present.
void setEvalOutIsSafeVector(const std::vector< bool > &eval_out_is_safe_vector)
Sets if an cut-off path is safe.
void setFlagsSleepModeOutputIsValid(bool flags_sleep_mode_output_is_valid)
Sets if the sleep mode is valid.
void setMonitoringCaseFlagsVector(const std::vector< bool > &monitoring_case_flags_vector)
Set is the corresponding monitoring case number is valid.
void setHostErrorFlagContaminationError(bool host_error_flag_contamination_error)
Sets if a contamination error is present.
void setHostErrorFlagManipulationError(bool host_error_flag_manipulation_error)
Sets if a manipulation error is present.
std::vector< bool > getMonitoringCaseFlagsVector() const
Gets if the corresponding monitoring case number is valid.
ApplicationOutputs()
Constructor of the application outputs.
void setEvalOutVector(const std::vector< bool > &eval_out_vector)
Set the state of the non safe cut-off paths.
bool getHostErrorFlagManipulationError() const
Gets if a manipulation error is present.
bool getVelocity0TransmittedSafely() const
Gets if the first linear velocity output is transmitted safely.
void setFlagsHostErrorFlagsAreValid(bool flags_host_error_flags_are_valid)
Sets if the error flags are valid.
std::vector< bool > m_resulting_velocity_is_valid_vector
bool getHostErrorFlagCriticalError() const
Gets if a critical error is present.
std::vector< bool > getEvalOutIsValidVector() const
If the output path is valid.
int8_t getSleepModeOutput() const
Gets the state of the sleep mode.
bool getVelocity0Valid() const
Gets if the first linear velocity output is valid.
void setVelocity1(const int16_t &velocity_1)
Sets the second linear velocity output.
bool getVelocity1Valid() const
Gets if the second linear velocity output is valid.
std::vector< int16_t > getResultingVelocityVector() const
Gets the resulting velocity for each monitoring case table.


sick_safetyscanners
Author(s): Lennart Puck
autogenerated on Fri Apr 2 2021 02:45:41