Raylase driver: Enabled IO Cycles

Author: alexanderoster

Drivers/RayLase/Implementation/libmcdriver_raylase_raylasecardimpl.cpp

@@ -70,6 +70,7 @@ CRaylaseCardImpl::CRaylaseCardImpl(PRaylaseSDK pSDK, const std::string& sCardNam
         throw ELibMCDriver_RaylaseInterfaceException(LIBMCDRIVER_RAYLASE_ERROR_INVALIDPARAM);
 
     m_pNLightDriverImpl = std::make_shared<CNLightDriverImpl>(m_pSDK, m_pDriverEnvironment);
+    m_pIOCycleMapping = std::make_shared<CRaylaseCardIOCycleMapping>();
 
     if ((dMaxLaserPowerInWatts < RAYLASE_MINLASERPOWER) || (dMaxLaserPowerInWatts > RAYLASE_MAXLASERPOWER))
         throw ELibMCDriver_RaylaseInterfaceException(LIBMCDRIVER_RAYLASE_ERROR_INVALIDLASERPOWER, "invalid laser power: " + std::to_string (dMaxLaserPowerInWatts));
@@ -348,7 +349,7 @@ LibMCEnv::PDriverEnvironment CRaylaseCardImpl::getDriverEnvironment()
 
 PRaylaseCardList CRaylaseCardImpl::createNewList()
 {
-    return std::make_shared<CRaylaseCardList>(m_pSDK, m_Handle, m_dMaxLaserPowerInWatts, m_pCoordinateTransform, m_PartSuppressions, m_pNLightDriverImpl);
+    return std::make_shared<CRaylaseCardList>(m_pSDK, m_Handle, m_dMaxLaserPowerInWatts, m_pCoordinateTransform, m_PartSuppressions, m_pNLightDriverImpl, m_pIOCycleMapping);
 }
 
 void CRaylaseCardImpl::abortListExecution()
@@ -385,35 +386,25 @@ double CRaylaseCardImpl::getMaxLaserPowerInWatts()
 
 PRaylaseIOCycleImpl CRaylaseCardImpl::createIOCycle(uint32_t nCycleID)
 {
-    if (nCycleID == 0)
-        throw ELibMCDriver_RaylaseInterfaceException(LIBMCDRIVER_RAYLASE_ERROR_INVALIDIOCYCLEID);
-
-    auto iIter = m_IOCycles.find(nCycleID);
-    if (iIter != m_IOCycles.end())
-        throw ELibMCDriver_RaylaseInterfaceException(LIBMCDRIVER_RAYLASE_ERROR_IOCYCLEALREADYEXISTS);
-
-    auto pIOCycle = std::make_shared<CRaylaseIOCycleImpl>(nCycleID);
-    m_IOCycles.insert(std::make_pair(nCycleID, pIOCycle));
-
-    return pIOCycle;
+    return m_pIOCycleMapping->createIOCycle(nCycleID);
 }
 
 bool CRaylaseCardImpl::ioCycleExists(uint32_t nCycleID) const
 {
-    auto iIter = m_IOCycles.find(nCycleID);
-    return (iIter != m_IOCycles.end());
+    return m_pIOCycleMapping->ioCycleExists(nCycleID);
 }
 
 PRaylaseIOCycleImpl CRaylaseCardImpl::getIOCycle(uint32_t nCycleID) const
 {
-    auto iIter = m_IOCycles.find(nCycleID);
-    if (iIter == m_IOCycles.end())
-        throw ELibMCDriver_RaylaseInterfaceException(LIBMCDRIVER_RAYLASE_ERROR_IOCYCLENOTFOUND);
-
-    return iIter->second;
+    return m_pIOCycleMapping->getIOCycle(nCycleID);
 }
 
 void CRaylaseCardImpl::removeIOCycle(uint32_t nCycleID)
 {
-    m_IOCycles.erase(nCycleID);
+    m_pIOCycleMapping->removeIOCycle(nCycleID);
+}
+
+PRaylaseCardIOCycleMapping CRaylaseCardImpl::getIOCycleMapping()
+{
+    return m_pIOCycleMapping;
 }

Drivers/RayLase/Implementation/libmcdriver_raylase_raylasecardimpl.hpp

@@ -39,7 +39,7 @@ Abstract: This is the class declaration of CRaylaseCard
 #include "libmcdriver_raylase_sdk.hpp"
 #include "libmcdriver_raylase_raylasecardlist.hpp"
 #include "libmcdriver_raylase_nlightdriverimpl.hpp"
-#include "libmcdriver_raylase_raylaseiocycleimpl.hpp"
+#include "libmcdriver_raylase_raylaseiocyclemapping.hpp"
 
 namespace LibMCDriver_Raylase {
 namespace Impl {
@@ -87,7 +87,7 @@ class CRaylaseCardImpl {
 	PNLightDriverImpl m_pNLightDriverImpl;
 
 	std::map<std::string, ePartSuppressionMode> m_PartSuppressions;
-	std::map<uint32_t, PRaylaseIOCycleImpl> m_IOCycles;
+	PRaylaseCardIOCycleMapping m_pIOCycleMapping;
 
 public:
 
@@ -159,6 +159,8 @@ class CRaylaseCardImpl {
 
 	void removeIOCycle(uint32_t nCycleID);
 
+	PRaylaseCardIOCycleMapping getIOCycleMapping();
+
 };
 
 } // namespace Impl

Drivers/RayLase/Implementation/libmcdriver_raylase_raylasecardlist.cpp

@@ -87,15 +87,16 @@ void CRaylaseCoordinateTransform::applyTransform(double& dX, double& dY)
 }
 
 
-CRaylaseCardList::CRaylaseCardList(PRaylaseSDK pSDK, rlHandle cardHandle, double dMaxLaserPowerInWatts, PRaylaseCoordinateTransform pCoordinateTransform, const std::map<std::string, ePartSuppressionMode>& partSuppressions, PNLightDriverImpl pNLightBoardImpl)
+CRaylaseCardList::CRaylaseCardList(PRaylaseSDK pSDK, rlHandle cardHandle, double dMaxLaserPowerInWatts, PRaylaseCoordinateTransform pCoordinateTransform, const std::map<std::string, ePartSuppressionMode>& partSuppressions, PNLightDriverImpl pNLightBoardImpl, PRaylaseCardIOCycleMapping pIOCycleMapping)
     : m_pSDK(pSDK), 
     m_ListHandle(0), 
     m_CardHandle(cardHandle), 
     m_dMaxLaserPowerInWatts_Mode0(dMaxLaserPowerInWatts),
     m_nListIDOnCard (RAYLASE_LISTONCARDNOTSET),
     m_pCoordinateTransform (pCoordinateTransform),
     m_PartSuppressions (partSuppressions),
-    m_pNLightBoardImpl (pNLightBoardImpl)
+    m_pNLightBoardImpl (pNLightBoardImpl),
+    m_pIOCycleMapping (pIOCycleMapping)
 
 {
     if (pSDK.get() == nullptr)
@@ -165,6 +166,16 @@ void CRaylaseCardList::addLayerToList(LibMCEnv::PToolpathLayer pLayer, uint32_t
 
     double dUnits = pLayer->GetUnits();
 
+	// Check if pre/post cycle attributes are present
+    uint32_t nPreCycleAttributeID = 0;
+    if (pLayer->HasCustomSegmentAttribute("http://schemas.raylase.com/iocontrol/2026/01", "precycleid"))
+        nPreCycleAttributeID = pLayer->FindCustomSegmentAttributeID("http://schemas.raylase.com/iocontrol/2026/01", "precycleid");
+
+    uint32_t nPostCycleAttributeID = 0;
+    if (pLayer->HasCustomSegmentAttribute("http://schemas.raylase.com/iocontrol/2026/01", "postcycleid"))
+        nPostCycleAttributeID = pLayer->FindCustomSegmentAttributeID("http://schemas.raylase.com/iocontrol/2026/01", "postcycleid");
+
+
     m_pSDK->checkError(m_pSDK->rlListAppendLaserOff(m_ListHandle), "rlListAppendLaserOff");
 
     uint32_t nSegmentCount = pLayer->GetSegmentCount();
@@ -196,6 +207,16 @@ void CRaylaseCardList::addLayerToList(LibMCEnv::PToolpathLayer pLayer, uint32_t
                 bDrawSegment = false;
         }
 
+
+        // Check for pre/postcycles to execute.
+        int64_t nPreCycleID = 0;
+        if (nPreCycleAttributeID != 0)
+            nPreCycleID = pLayer->GetSegmentIntegerAttribute(nSegmentIndex, nPreCycleAttributeID);
+
+        int64_t nPostCycleID = 0;
+        if (nPostCycleAttributeID != 0)
+			nPostCycleID = pLayer->GetSegmentIntegerAttribute(nSegmentIndex, nPostCycleAttributeID);
+       
         // Check if part is not to be ignored
         std::string sSegmentPartUUID = pLayer->GetSegmentPartUUID(nSegmentIndex);
         ePartSuppressionMode suppressionMode = getPartSuppressionMode(sSegmentPartUUID);
@@ -230,6 +251,17 @@ void CRaylaseCardList::addLayerToList(LibMCEnv::PToolpathLayer pLayer, uint32_t
                 }
 
             }
+
+
+            // Execute pre-cycle if specified
+            if (nPreCycleID != 0) {
+                if (m_pIOCycleMapping.get() == nullptr)
+                    throw ELibMCDriver_RaylaseInterfaceException(LIBMCDRIVER_RAYLASE_ERROR_IOCYCLENOTFOUND, "Pre-cycle ID " + std::to_string(nPreCycleID) + " specified but no IO cycle mapping available");
+                if (!m_pIOCycleMapping->ioCycleExists((uint32_t)nPreCycleID))
+                    throw ELibMCDriver_RaylaseInterfaceException(LIBMCDRIVER_RAYLASE_ERROR_IOCYCLENOTFOUND, "Pre-cycle ID " + std::to_string(nPreCycleID) + " not found");
+                auto pPreCycle = m_pIOCycleMapping->getIOCycle((uint32_t)nPreCycleID);
+                executeIOCycle(pPreCycle);
+            }
 
 
             double dJumpSpeedInMeterPerSecond = dJumpSpeedInMMPerSecond * 0.001;
@@ -345,6 +377,16 @@ void CRaylaseCardList::addLayerToList(LibMCEnv::PToolpathLayer pLayer, uint32_t
 
             }
 
+            // Execute post-cycle if specified
+            if (nPostCycleID != 0) {
+                if (m_pIOCycleMapping.get() == nullptr)
+                    throw ELibMCDriver_RaylaseInterfaceException(LIBMCDRIVER_RAYLASE_ERROR_IOCYCLENOTFOUND, "Post-cycle ID " + std::to_string(nPostCycleID) + " specified but no IO cycle mapping available");
+                if (!m_pIOCycleMapping->ioCycleExists((uint32_t)nPostCycleID))
+                    throw ELibMCDriver_RaylaseInterfaceException(LIBMCDRIVER_RAYLASE_ERROR_IOCYCLENOTFOUND, "Post-cycle ID " + std::to_string(nPostCycleID) + " not found");
+                auto pPostCycle = m_pIOCycleMapping->getIOCycle((uint32_t)nPostCycleID);
+                executeIOCycle(pPostCycle);
+            }
+
         }
 
     }
@@ -430,3 +472,67 @@ LibMCDriver_Raylase::ePartSuppressionMode CRaylaseCardList::getPartSuppressionMo
 }
 
 
+void CRaylaseCardList::executeIOCycle(PRaylaseIOCycleImpl pIOCycle)
+{
+    if (pIOCycle.get() == nullptr)
+        return;
+
+    const auto& entries = pIOCycle->getEntries();
+    for (const auto& entry : entries) {
+        switch (entry.m_EntryType) {
+        case eIOCycleEntryType::SignalOut:
+        {
+            // Convert LibMCDriver_Raylase::eIOPort to eRLIOPort
+            eRLIOPort rlPort = eRLIOPort::ioPortA;
+            switch (entry.m_IOPort) {
+            case eIOPort::PortA: rlPort = eRLIOPort::ioPortA; break;
+            case eIOPort::PortB: rlPort = eRLIOPort::ioPortB; break;
+            case eIOPort::PortC: rlPort = eRLIOPort::ioPortC; break;
+            case eIOPort::PortD: rlPort = eRLIOPort::ioPortD; break;
+            case eIOPort::PortE: rlPort = eRLIOPort::ioPortE; break;
+            default:
+                throw ELibMCDriver_RaylaseInterfaceException(LIBMCDRIVER_RAYLASE_ERROR_INVALIDIOPORT);
+            }
+
+            // Set the pin high using the pin mask
+            uint32_t nPinMask = (1u << entry.m_nIOPin);
+            m_pSDK->checkError(m_pSDK->rlListAppendGpioValue(m_ListHandle, rlPort, eRLPinAction::paSet, nPinMask), "rlListAppendGpioValue");
+            break;
+        }
+
+        case eIOCycleEntryType::WaitForSignal:
+        {
+            // Convert LibMCDriver_Raylase::eIOPort to eRLIOPort
+            eRLIOPort rlPort = eRLIOPort::ioPortA;
+            switch (entry.m_IOPort) {
+            case eIOPort::PortA: rlPort = eRLIOPort::ioPortA; break;
+            case eIOPort::PortB: rlPort = eRLIOPort::ioPortB; break;
+            case eIOPort::PortC: rlPort = eRLIOPort::ioPortC; break;
+            case eIOPort::PortD: rlPort = eRLIOPort::ioPortD; break;
+            case eIOPort::PortE: rlPort = eRLIOPort::ioPortE; break;
+            default:
+                throw ELibMCDriver_RaylaseInterfaceException(LIBMCDRIVER_RAYLASE_ERROR_INVALIDIOPORT);
+            }
+
+            // Wait for input signal on the specified pin
+            uint32_t nPinMask = (1u << entry.m_nIOPin);
+            int32_t nTimeoutInMicroseconds = (int32_t)entry.m_nTimeoutOrDelayInMicroseconds;
+            m_pSDK->checkError(m_pSDK->rlListAppendWaitForInput(m_ListHandle, nPinMask, rlPort, true, false, nPinMask, nTimeoutInMicroseconds), "rlListAppendWaitForInput");
+            break;
+        }
+
+        case eIOCycleEntryType::Delay:
+        {
+            // Delay is specified in microseconds, SDK expects seconds
+            double dDelayInSeconds = (double)entry.m_nTimeoutOrDelayInMicroseconds / 1000000.0;
+            m_pSDK->checkError(m_pSDK->rlListAppendSleep(m_ListHandle, dDelayInSeconds), "rlListAppendSleep");
+            break;
+        }
+
+        default:
+            break;
+        }
+    }
+}
+
+

Drivers/RayLase/Implementation/libmcdriver_raylase_raylasecardlist.hpp

@@ -38,6 +38,7 @@ Abstract: This is the class declaration of CRaylaseCard
 #include "libmcdriver_raylase_interfaces.hpp"
 #include "libmcdriver_raylase_sdk.hpp"
 #include "libmcdriver_raylase_nlightdriverimpl.hpp"
+#include "libmcdriver_raylase_raylaseiocyclemapping.hpp"
 
 #include <map>
 
@@ -91,10 +92,13 @@ class CRaylaseCardList
 
 		std::map<std::string, ePartSuppressionMode> m_PartSuppressions;
 		PNLightDriverImpl m_pNLightBoardImpl;
+		PRaylaseCardIOCycleMapping m_pIOCycleMapping;
+
+		void executeIOCycle(PRaylaseIOCycleImpl pIOCycle);
 
 	public:
 
-		CRaylaseCardList(PRaylaseSDK pSDK, rlHandle cardHandle, double dMaxLaserPowerInWatts, PRaylaseCoordinateTransform pCoordinateTransform, const std::map<std::string, ePartSuppressionMode> & partSuppressions, PNLightDriverImpl pNLightBoardImpl);
+		CRaylaseCardList(PRaylaseSDK pSDK, rlHandle cardHandle, double dMaxLaserPowerInWatts, PRaylaseCoordinateTransform pCoordinateTransform, const std::map<std::string, ePartSuppressionMode> & partSuppressions, PNLightDriverImpl pNLightBoardImpl, PRaylaseCardIOCycleMapping pIOCycleMapping);
 
 		virtual ~CRaylaseCardList();
 

Drivers/RayLase/Implementation/libmcdriver_raylase_raylaseiocyclemapping.cpp

@@ -0,0 +1,90 @@
+/*++
+
+Copyright (C) 2020 Autodesk Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Autodesk Inc. nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Abstract: This is the implementation of CRaylaseCardIOCycleMapping
+
+*/
+
+#include "libmcdriver_raylase_raylaseiocyclemapping.hpp"
+#include "libmcdriver_raylase_interfaceexception.hpp"
+
+using namespace LibMCDriver_Raylase::Impl;
+
+CRaylaseCardIOCycleMapping::CRaylaseCardIOCycleMapping()
+{
+}
+
+CRaylaseCardIOCycleMapping::~CRaylaseCardIOCycleMapping()
+{
+}
+
+PRaylaseIOCycleImpl CRaylaseCardIOCycleMapping::createIOCycle(uint32_t nCycleID)
+{
+	if (nCycleID == 0)
+		throw ELibMCDriver_RaylaseInterfaceException(LIBMCDRIVER_RAYLASE_ERROR_INVALIDIOCYCLEID);
+
+	auto iIter = m_IOCycles.find(nCycleID);
+	if (iIter != m_IOCycles.end())
+		throw ELibMCDriver_RaylaseInterfaceException(LIBMCDRIVER_RAYLASE_ERROR_IOCYCLEALREADYEXISTS);
+
+	auto pIOCycle = std::make_shared<CRaylaseIOCycleImpl>(nCycleID);
+	m_IOCycles.insert(std::make_pair(nCycleID, pIOCycle));
+
+	return pIOCycle;
+}
+
+bool CRaylaseCardIOCycleMapping::ioCycleExists(uint32_t nCycleID) const
+{
+	auto iIter = m_IOCycles.find(nCycleID);
+	return (iIter != m_IOCycles.end());
+}
+
+PRaylaseIOCycleImpl CRaylaseCardIOCycleMapping::getIOCycle(uint32_t nCycleID) const
+{
+	auto iIter = m_IOCycles.find(nCycleID);
+	if (iIter == m_IOCycles.end())
+		throw ELibMCDriver_RaylaseInterfaceException(LIBMCDRIVER_RAYLASE_ERROR_IOCYCLENOTFOUND);
+
+	return iIter->second;
+}
+
+void CRaylaseCardIOCycleMapping::removeIOCycle(uint32_t nCycleID)
+{
+	m_IOCycles.erase(nCycleID);
+}
+
+void CRaylaseCardIOCycleMapping::clearAllIOCycles()
+{
+	m_IOCycles.clear();
+}
+
+size_t CRaylaseCardIOCycleMapping::getIOCycleCount() const
+{
+	return m_IOCycles.size();
+}