post_processor.hpp

Go to the documentation of this file.

#ifndef FANUC_POST_PROCESSOR_HPP
#define FANUC_POST_PROCESSOR_HPP

#include <algorithm>
#include <fanuc_post_processor/commands.hpp>
#include <fanuc_post_processor/curlite.hpp>
#include <fanuc_post_processor/pose.hpp>
#include <fstream>
#include <limits>
#include <ros/ros.h>
#include <stdexcept>
#include <string>

namespace fanuc_post_processor
{
class FanucPostProcessor
{
public:
  enum MovementType
  {
    JOINT, LINEAR
  };

  enum SpeedType
  {
    MM_SEC, CM_SEC, M_SEC, MM_MIN, CM_MIN, M_MIN, PERCENTAGE
  };

  enum Permissions
  {
    READ_WRITE, READ
  };

public:
  FanucPostProcessor();

  ~FanucPostProcessor();

  typedef std::string ProgramName;
  typedef std::string Program;
  unsigned generatePrograms(std::vector<std::pair<ProgramName, Program>> &output_programs,
                            const unsigned lines_per_program = 0);

  void clearProgram();

  void useLineNumbers(bool line_numbers);

  void
  uploadToFtp(const std::vector<std::pair<ProgramName, Program>> programs,
              const std::string ip_address,
              const std::string port_number = "21",
              const std::string username = "",
              const std::string password = "");

  void setProgramName(std::string name);

  void setProgramComment(const std::string comment);

  void setMemorySize(const unsigned size);

  void setPermissions(const FanucPostProcessor::Permissions perms);

  void setApplicative(const std::string appl);

  void
  appendPose(FanucPose &pose);

  void
  appendPoseId(FanucPose &pose);

  void
  appendComment(const std::string comment);

  void
  appendEmptyLine();

  void
  appendDigitalOutput(const unsigned digital_out_id,
                      const bool state);

  void
  appendDigitalOutput(const unsigned digital_out_id,
                      const double pulse_time);

  void
  appendWait(const double time);

  void
  appendWait(const unsigned digital_in_id,
             bool state);

  void
  appendUFrame(const unsigned uf_id);

  void
  appendUTool(const unsigned ut_id);

  void
  appendGroupOutput(const unsigned id,
                    const unsigned value);

  void
  appendSetRegister(const unsigned r_id,
                    const double value);

  void
  appendCall(const std::string program_name);

  void
  appendRun(const std::string program_name);

  void
  appendLabel(const unsigned id);

  void
  appendJumpLabel(const unsigned id);

  void
  appendDataMonitorStart(const unsigned id);

  void
  appendDataMonitorStop();

  void appendFor(const unsigned reg_id,
                 const std::string start,
                 const std::string stop);

  void appendFor(const unsigned reg_id,
                 const unsigned start,
                 const unsigned stop);

  void appendEndFor();

  void appendCustomCommand(const std::string command);

  bool getPoseFromId(const unsigned pose_id,
                     FanucPose &pose);

private:
  void prependLineNumber(std::string &line,
                         const unsigned number);

  bool tweakProgramName(ProgramName &name,
                        const unsigned number);

  const unsigned program_name_max_size_ = 36;

  std::string permissionsToString(Permissions perm)
  {
    if (perm == READ_WRITE)
      return "READ_WRITE";
    if (perm == READ)
      return "READ";
    else
      return "";
  }

  std::string program_name_;

  std::string program_comment_;

  FanucPostProcessor::Permissions permissions_;

  std::string applicative_;

  std::vector<std::shared_ptr<FanucCommand>> commands_;

  std::vector<unsigned> labels_id_;

  bool line_numbers_;

  unsigned for_count_;

  std::vector<FanucPose> poses_;
};

}
#endif