scanner_frames.h

Go to the documentation of this file.

// Copyright (c) 2019 Pilz GmbH & Co. KG
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

#ifndef PSEN_SCAN_SCANNER_FRAMES_H
#define PSEN_SCAN_SCANNER_FRAMES_H

#include <cstdint>
#include <array>

#include <psen_scan/psen_scan_internal_angle.h>

namespace psen_scan
{
#pragma pack(push, 1)  // Don't allow padding

typedef struct StartMonitoringFrame
{
  uint32_t crc_;                  
  uint32_t const RESERVED_;       
  char password_[8];              
  uint32_t const OPCODE_;         
  uint32_t host_ip_;              
  uint32_t host_udp_port_;        
  uint64_t const FIXED_SEQUENCE_; 
  std::array<uint16_t, 12> const RESERVED2_; 
  StartMonitoringFrame(const std::string& password = "",
                       const uint32_t& host_ip = 0,
                       const uint32_t& host_udp_port = 0);

} StartMonitoringFrame;

typedef struct StopMonitoringFrame
{
  uint32_t crc_;            
  uint32_t const RESERVED_; 
  char password_[8];        
  uint32_t const OPCODE_;   
  StopMonitoringFrame(const std::string& password = "");

} StopMonitoringFrame;

typedef struct PhysicalInputs
{
  uint32_t time_stamp_;                   
  std::array<uint8_t, 10> input_signals_; 
} PhysicalInputs;

typedef struct LogicalInputs
{
  uint32_t time_stamp_;                  
  std::array<uint8_t, 8> input_signals_; 
} LogicalInputs;

typedef struct InputStateArea
{
  std::array<PhysicalInputs, 3> physical_inputs_;
  LogicalInputs logical_inputs_;
} InputStateArea;

typedef struct OutputStateArea
{
  uint32_t time_stamp_; 
  uint32_t outputs_;    
} OutputStateArea;

typedef struct DiagnosticInformation
{
  uint8_t internal_error_1_ : 5;
  uint8_t integrity_check_problem_on_any_ossd_ : 1;
  uint8_t short_circuit_at_least_two_ossd_ : 1;
  uint8_t ossd1_short_circuit_ : 1;

  uint8_t : 2;
  uint8_t internal_error_2_ : 2;
  uint8_t dust_circuit_failure_ : 1;
  uint8_t network_problem_ : 1;
  uint8_t power_supply_problem_ : 1;
  uint8_t window_cleaning_alarm_ : 1;

  uint8_t window_cleaning_warning_ : 1;
  uint8_t zone_invalid_input_configuration_connection_ : 1;
  uint8_t zone_invalid_input_transition_or_integrity_ : 1;
  uint8_t incoherence_data_ : 1;
  uint8_t internal_error_3_ : 3;
  uint8_t measure_problem_ : 1;

  uint8_t temperature_measurement_problem_ : 1;
  uint8_t internal_error_5_ : 2;
  uint8_t display_communication_problem_ : 1;
  uint8_t generic_error_ : 1;
  uint8_t internal_error_4_ : 2;
  uint8_t internal_communication_problem_ : 1;

  uint8_t temperature_range_error_ : 1;
  uint8_t out_of_range_error_ : 1;
  uint8_t configuration_error_ : 1;
  uint8_t : 5;

  std::array<uint8_t, 15> unused;
} DiagnosticInformation;

typedef struct DiagnosticArea
{
  uint32_t time_stamp_; 
  DiagnosticInformation diagnostic_information_;
} DiagnosticArea;

typedef struct MonitoringFrame
{
  uint32_t device_status_;            
  uint32_t opcode_;                   
  uint32_t working_mode_;             
  uint32_t transaction_type_;         
  InputStateArea input_state_area_;   
  OutputStateArea output_state_area_; 
  DiagnosticArea diagnostic_area_;    
  uint8_t scanner_id_;                
  uint8_t resolution_;                
  uint16_t from_theta_;
  uint16_t number_of_samples_;
  std::array<uint16_t, 550> measures_;
  uint32_t scan_counter_;
  PSENscanInternalAngle to_theta() const
  {
    return PSENscanInternalAngle(from_theta_ + static_cast<uint16_t>(resolution_) * number_of_samples_);
  }
} MonitoringFrame;

#pragma pack(pop)
}  // namespace psen_scan

#endif  // PSEN_SCAN_SCANNER_FRAMES_H