eni.h

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <expected>
#include <nlohmann/json_fwd.hpp>
#include <optional>
#include <span>
#include <string>
#include <vector>
 
namespace mm::etg {
 
 
enum class EniTransition : std::uint8_t {
  II,  
  IP,  
  PP,  
  PO,  
  PS,  
  PI,  
  SS,  
  SP,  
  SO,  
  SI,  
  OS,  
  OP,  
  OI,  
  IB,  
  BI,  
};
 
enum class EniCmd : std::uint8_t {
  Nop = 0,    
  Aprd = 1,   
  Apwr = 2,   
  Aprw = 3,   
  Fprd = 4,   
  Fpwr = 5,   
  Fprw = 6,   
  Brd = 7,    
  Bwr = 8,    
  Brw = 9,    
  Lrd = 10,   
  Lwr = 11,   
  Lrw = 12,   
  Armw = 13,  
  Frmw = 14,  
};
 
enum class EniRequires : std::uint8_t {
  None,   
  Frame,  
  Cycle,  
};
 
enum class EniState : std::uint8_t {
  Init,    
  PreOp,   
  SafeOp,  
  Op,      
};
 
enum class EniSyncManagerType : std::uint8_t {
  MailboxOut,  
  MailboxIn,   
  Outputs,     
  Inputs,      
};
 
enum class EniMailboxProtocol : std::uint8_t {
  Aoe,  
  Eoe,  
  Coe,  
  Soe,  
  Foe,  
  Voe,  
};
 
enum class EniCoeCommandSpecifier : std::uint8_t {
  Download = 1,  
  Upload = 2,    
};
 
struct EniValidate {
  std::vector<std::uint8_t> data;      
  std::vector<std::uint8_t> dataMask;  
  std::uint32_t timeoutMs = 0;         
};
 
struct EniEcatCmd {
  std::vector<EniTransition> transitions;  
  bool beforeSlave = false;                
  std::string comment;                     
  EniRequires requirement = EniRequires::None;  
  EniCmd cmd = EniCmd::Nop;           
  std::optional<std::uint16_t> adp;   
  std::optional<std::uint16_t> ado;   
  std::optional<std::uint32_t> addr;  
  std::vector<std::uint8_t> data;     
  std::optional<std::uint32_t> dataLength;  
  std::optional<std::uint32_t> cnt;         
  std::optional<std::uint32_t> retries;     
  std::optional<EniValidate> validate;      
  std::optional<std::uint32_t> timeoutMs;   
};
 
struct EniCoeCmd {
  std::vector<EniTransition> transitions;  
  std::string comment;                     
  std::uint32_t timeoutMs = 0;             
  EniCoeCommandSpecifier ccs = EniCoeCommandSpecifier::Download;  
  std::uint16_t index = 0;                                        
  std::uint8_t subindex = 0;                                      
  std::vector<std::uint8_t> data;  
  bool disabled = false;           
};
 
struct EniProcessDataWindow {
  std::uint32_t bitStart = 0;   
  std::uint32_t bitLength = 0;  
};
 
struct EniSyncManager {
  std::uint8_t index = 0;                                    
  EniSyncManagerType type = EniSyncManagerType::MailboxOut;  
  std::uint16_t startAddress = 0;  
  std::uint8_t controlByte = 0;    
  bool enable = false;             
  std::optional<std::uint32_t> minSize;      
  std::optional<std::uint32_t> maxSize;      
  std::optional<std::uint32_t> defaultSize;  
  std::optional<std::uint32_t> watchdog;     
};
 
struct EniPdoEntry {
  std::uint16_t index = 0;    
  std::uint8_t subindex = 0;  
  std::uint16_t bitLen = 0;   
  std::string name;           
  std::string dataType;       
  std::string comment;        
};
 
struct EniPdo {
  std::uint16_t index =
      0;             
  std::string name;  
  std::optional<std::uint8_t> syncManager;  
  bool fixed = false;                
  bool mandatory = false;            
  std::vector<EniPdoEntry> entries;  
};
 
struct EniProcessData {
  std::optional<EniProcessDataWindow> send;  
  std::optional<EniProcessDataWindow> recv;  
  std::vector<EniSyncManager> syncManagers;  
  std::vector<EniPdo> rxPdos;                
  std::vector<EniPdo> txPdos;                
};
 
struct EniMailboxWindow {
  std::uint16_t start = 0;                     
  std::uint16_t length = 0;                    
  std::optional<std::uint32_t> pollTime;       
  std::optional<std::uint32_t> statusBitAddr;  
};
 
struct EniMailbox {
  EniMailboxWindow send;                          
  EniMailboxWindow recv;                          
  std::optional<EniMailboxWindow> bootstrapSend;  
  std::optional<EniMailboxWindow> bootstrapRecv;  
  std::vector<EniMailboxProtocol> protocols;      
  std::vector<EniCoeCmd> coeInitCmds;             
};
 
struct EniSlaveInfo {
  std::string name;               
  std::uint16_t physAddr = 0;     
  std::uint16_t autoIncAddr = 0;  
  std::string physics;            
  std::uint32_t vendorId = 0;     
  std::uint32_t productCode = 0;  
  std::uint32_t revisionNo = 0;   
  std::uint32_t serialNo = 0;     
};
 
enum class EniPort : std::uint8_t {
  A,  
  B,  
  C,  
  D,  
};
 
struct EniPreviousPort {
  EniPort port = EniPort::B;              
  bool selected = false;                  
  std::optional<std::uint16_t> physAddr;  
  std::optional<std::uint32_t> deviceId;  
};
 
struct EniDc {
  std::optional<bool> potentialReferenceClock;  
  std::optional<bool> referenceClock;           
  std::optional<std::int32_t> cycleTime0Ns;     
  std::optional<std::int32_t> cycleTime1Ns;     
  std::optional<std::int32_t> shiftTimeNs;      
};
 
struct EniSlave {
  EniSlaveInfo info;                           
  std::optional<EniProcessData> processData;   
  std::optional<EniMailbox> mailbox;           
  std::vector<EniEcatCmd> initCmds;            
  std::vector<EniPreviousPort> previousPorts;  
  std::optional<EniDc> dc;                     
};
 
struct EniCyclicCmd {
  std::vector<EniState> states;  
  std::string comment;           
  EniCmd cmd = EniCmd::Lrw;      
  std::optional<std::uint16_t> adp;   
  std::optional<std::uint16_t> ado;   
  std::optional<std::uint32_t> addr;  
  std::vector<std::uint8_t> data;     
  std::optional<std::uint32_t> dataLength;  
  std::optional<std::uint32_t> cnt;         
  std::uint32_t inputOffs = 0;              
  std::uint32_t outputOffs = 0;             
};
 
struct EniFrame {
  std::string comment;             
  std::vector<EniCyclicCmd> cmds;  
};
 
struct EniCyclic {
  std::string comment;                       
  std::optional<std::uint32_t> cycleTimeUs;  
  std::optional<std::uint32_t> priority;     
  std::string taskId;                        
  std::vector<EniFrame> frames;              
};
 
struct EniVariable {
  std::string name;           
  std::string comment;        
  std::string dataType;       
  std::uint32_t bitSize = 0;  
  std::uint32_t bitOffs = 0;  
};
 
struct EniProcessImageArea {
  std::uint32_t byteSize = 0;          
  std::vector<EniVariable> variables;  
};
 
struct EniProcessImage {
  std::optional<EniProcessImageArea> inputs;   
  std::optional<EniProcessImageArea> outputs;  
};
 
struct EniMailboxStates {
  std::uint32_t startAddr = 0;  
  std::uint32_t count = 0;      
};
 
struct EniEoe {
  std::uint32_t maxPorts = 0;   
  std::uint32_t maxFrames = 0;  
  std::uint32_t maxMacs = 0;    
};
 
struct EniMaster {
  std::string name;                        
  std::vector<std::uint8_t> destination;   
  std::vector<std::uint8_t> source;        
  std::optional<std::uint16_t> etherType;  
  std::optional<EniMailboxStates> mailboxStates;  
  std::optional<EniEoe> eoe;                      
  std::vector<EniEcatCmd> initCmds;               
};
 
struct EniNetwork {
  EniMaster master;                             
  std::vector<EniSlave> slaves;                 
  std::optional<EniCyclic> cyclic;              
  std::optional<EniProcessImage> processImage;  
};
 
void to_json(nlohmann::json& j, const EniNetwork& network);
 
std::string eniPhysics(std::uint16_t physicalPort);
 
std::expected<std::string, std::string> writeEni(const EniNetwork& network);
 
}  // namespace mm::etg