omron_os32c_driver: measurement_report

26 #ifndef OMRON_OS32C_DRIVER_MEASUREMENT_REPORT_HEADER_H

27 #define OMRON_OS32C_DRIVER_MEASUREMENT_REPORT_HEADER_H

29 #include <string>

31 #include "odva_ethernetip/eip_types.h"

32 #include "odva_ethernetip/serialization/reader.h"

33 #include "odva_ethernetip/serialization/writer.h"

34 #include "odva_ethernetip/serialization/serializable.h"

36 using std::string;

37 using eip::serialization::Serializable;

38 using eip::serialization::Reader;

39 using eip::serialization::Writer;

41 namespace omron_os32c_driver {

47 class MeasurementReportHeader : public Serializable

48 {

49 public:

50 EIP_UDINT scan_count;

51 EIP_UDINT scan_rate;

52 EIP_UDINT scan_timestamp;

53 EIP_UDINT scan_beam_period;

54 EIP_UINT machine_state;

55 EIP_UINT machine_stop_reasons;

56 EIP_UINT active_zone_set;

57 EIP_WORD zone_inputs;

58 EIP_WORD detection_zone_status;

59 EIP_WORD output_status;

60 EIP_WORD input_status;

61 EIP_UINT display_status;

62 EIP_UINT non_safety_config_checksum;

63 EIP_UINT safety_config_checksum;

64 EIP_UINT range_report_format;

65 EIP_UINT refletivity_report_format;

66 EIP_UINT num_beams;

71 virtual size_t getLength() const

72 {

73 return 56;

74 }

82 virtual Writer& serialize(Writer& writer) const

83 {

84 EIP_UINT reserved = 0;

85 writer.write(scan_count);

86 writer.write(scan_rate);

87 writer.write(scan_timestamp);

88 writer.write(scan_beam_period);

89 writer.write(machine_state);

90 writer.write(machine_stop_reasons);

91 writer.write(active_zone_set);

92 writer.write(zone_inputs);

93 writer.write(detection_zone_status);

94 writer.write(output_status);

95 writer.write(input_status);

96 writer.write(display_status);

97 writer.write(non_safety_config_checksum);

98 writer.write(safety_config_checksum);

99 writer.write(reserved);

100 writer.write(reserved);

101 writer.write(reserved);

102 writer.write(reserved);

103 writer.write(reserved);

104 writer.write(reserved);

105 writer.write(range_report_format);

106 writer.write(refletivity_report_format);

107 writer.write(reserved);

108 writer.write(num_beams);

109 return writer;

110 }

111

115 virtual Reader& deserialize(Reader& reader, size_t length)

116 {

117 deserialize(reader);

118 return reader;

119 }

120

127 virtual Reader& deserialize(Reader& reader)

128 {

129 reader.read(scan_count);

130 reader.read(scan_rate);

131 reader.read(scan_timestamp);

132 reader.read(scan_beam_period);

133 reader.read(machine_state);

134 reader.read(machine_stop_reasons);

135 reader.read(active_zone_set);

136 reader.read(zone_inputs);

137 reader.read(detection_zone_status);

138 reader.read(output_status);

139 reader.read(input_status);

140 reader.read(display_status);

141 reader.read(non_safety_config_checksum);

142 reader.read(safety_config_checksum);

143 reader.skip(6 * sizeof(EIP_UINT));

144 reader.read(range_report_format);

145 reader.read(refletivity_report_format);

146 reader.skip(sizeof(EIP_UINT));

147 reader.read(num_beams);

148 return reader;

149 }

150 };

151

152 } // namespace omron_os32c_driver

153

154 #endif // OMRON_OS32C_DRIVER_MEASUREMENT_REPORT_HEADER_H