ServiceInterface.h

Go to the documentation of this file.

 
#ifndef SERVICEINTERFACE_H
#define SERVICEINTERFACE_H
#ifdef ARDUINO
    #include <Arduino.h>    // include Arduino-Library for platformIO-build 
#else
    #include <mockArduino.h>
    using namespace arduinoMocking;
#endif
 
#include <CommInterface.h>
#include <ServiceCluster.h>
#include <Frame.h>
#include <Content_stack.h>
#include <ErrorService.h>
#include <ErrorState.h>
 
#define STACKSIZE 2             // Size of Send- / Rec-Stack
#define ERRORSERVICE_ID 'e'     // Service-ID of the configured Error-Service in Servicecluster
//#define DEBUG
 
 
template<typename CommInterfaceBase, typename frameType>                                       
class ServiceInterface: public ErrorState{
    public:
        ServiceInterface(CommInterfaceBase* comm_interface, ServiceClusterBase* services):
                ErrorState(),
                comm_interface(comm_interface), 
                services(services) {};
 
        virtual void communicate() = 0;        
 
    protected:
        CommInterfaceBase* comm_interface;        
 
        ServiceClusterBase* services;                               
 
        Content_stack<frameType, STACKSIZE> recStack;     
 
        Content_stack<frameType, STACKSIZE> sendStack;        
 
        CharArray sendItem;  
 
        CharArray recItem;                                             
 
        virtual void getPDU_from_services()=0;
 
        virtual void addPDU_to_services()=0;
 
 
        virtual void processServices(){
            for (size_t i = 0; i < services->getNumberOfServices(); i++)
                {
                    ServiceBase* destinationService = services->getService_byPos(i);            // Pointer to the destination-Service 
                    destinationService->stackProcessing();
                }
        }
 
        void raiseError(errorCodes code) {
            ServiceBase* service = services->getService_byID(ERRORSERVICE_ID);
            if (service) {
                ErrorService* errService = static_cast<ErrorService*>(service);
                errService->raiseError(code);
            }else{
                ErrorState::raiseError(code);
            }
        };
 
        virtual void processSendStack(){
            // Serial debugging
            #ifdef DEBUG
                Serial.println("Processing Send-Stack...");
            #endif
            // Handle sendstack
            while (!sendStack.empty())
            {
                if (comm_interface->finishedSending()){
                    Frame* frameToSend = sendStack.getElement();                        // Get next item from the send-stack
                    sendItem = *frameToSend->get_representation();                      // buffer Frame as char-array
                    comm_interface->sendNewFrame(&sendItem);                            // Impart Frame that has to be sent next to the CommInterface
                    sendStack.deleteElement();                                          // delete Item from send-stack
                    comm_interface->sendCycle();                                        // execute sending 
                }else{
                    comm_interface->sendCycle();                                        // execute sending 
                };
                
                // check the commInterfaces ErrorState 
                errorCodes commInterfaceErrorState = comm_interface->getErrorState();
                if (commInterfaceErrorState!=noError) raiseError(commInterfaceErrorState);
                comm_interface->clearErrorState();            
            };        
        }
 
        virtual void addPDU_to_services()
        {
            // abort, if no new PDU available
            if (recStack.empty()) return;
            // Add all received PDUs to the Services 
            while (!recStack.empty())
            {
                // Try to add Frame from rec-stack to Service
                Frame* receivedFrame = recStack.getElement();     
                errorCodes ServicesErrorState = services->impartPdu(receivedFrame);
 
                // handle the Service-Clusters error-state
                if (ServicesErrorState != noError) raiseError(ServicesErrorState);
 
                // clear Error-state after handling error
                services->clearErrorState();
 
                // Skip Discard and leave the rec-stack-processing
                if (ServicesErrorState = overflow) break; 
 
                // discard frame
                recStack.deleteElement();
            };
        };
 
 
        virtual void processRecStack() {
            // Serial debugging
            #ifdef DEBUG
                Serial.println("Processing Receive-Stack...");
            #endif                  
            // Handle receivebuffer 
            while (comm_interface->receivedNewFrame() && !recStack.full()){               
                if (recItem.getSize() != 0){                        // Item not empty 
                    frameType recItemFrame(&recItem);               // Construct Frame-Class derived Object (nullptr if failed)
                    if (recItemFrame.isValid()){
                        recStack.addElement(recItemFrame);          // Add the received element to the stack
                        }else{
                            raiseError(framingError);}              // frame-construction failed 
                    recItem = CharArray();                          // Clear rec-Item                               
                }
 
                // check the commInterfaces ErrorState 
                errorCodes commInterfaceErrorState = comm_interface->getErrorState();
                if (commInterfaceErrorState!=noError) raiseError(commInterfaceErrorState);
                comm_interface->clearErrorState(); 
 
                comm_interface->getReceivedFrame(&recItem);         // Impart memory the received item has to be stored at 
                comm_interface->receiveCycle();                     // Receive new frames from comm-interface 
            }
            comm_interface->receiveCycle();                         // Receive new frames from comm-interface
 
            // check the commInterfaces ErrorState 
            errorCodes commInterfaceErrorState = comm_interface->getErrorState();
            if (commInterfaceErrorState!=noError) raiseError(commInterfaceErrorState);
            comm_interface->clearErrorState(); 
        }
};
#endif // SERVICEINTERFACE_H