Reconfiguration

As discussed in the application kick-starting section, the Loader component (or any component inheriting from it) is responsible for configuring and starting a standard MARTe applicaton (i.e. one that relies on the MARTeApp.cpp).

The Loader component also offers a reconfiguration interface (see Loader::Reconfigure) that can be used in runtime to modify the configuration of an application that is already in execution.

Any component inheriting from the Loader class can implement the PostInit method in order to receive runtime configuration parameters (e.g. a TCP port where to listen for new configurations).

The Loader also offers a set of pre-defined message triggers that are sent: before the configuration is modified; after the configuration is (successfully) applied; in case a configuration error occurs; and if a configuration occurs and the user has configured the option to reload the last valid configuration.

Finally, the Loader components also allows to query the currently loaded configuration (see Loader::GetLastValidConfiguration).

The ConfigurationLoaderTCP in an implementation that allows changing the runtime configuration over a TCP connection.

Examples

Valid reconfiguration

This is an example of a MARTeApp that uses a ConfigurationLoaderTCP.

Start the application with the -m parameter.

To modify a configuration, start the application and, on another console, type nc localhost 24680 < RTApp-9-reload.cfg.

The new configuration has a higher cycle time so that the frequency at which the signals are printed into console should significantly increase.

To return to a configuration running at a lower frequency, on another console, type nc localhost 24680 < RTApp-9-reload-2.cfg.

ConfigurationLoaderTCP application (Run with NAME_OF_THE_MESSAGE=StateMachine:START and NAME_OF_THE_CONFIGURATION_FILE=RTApp-9.cfg)

+LoaderPostInit = {
    Class = ReferenceContainer
    +Parameters = {
        Class = ConfigurationDatabase
        Port = 24680//The port where to listen for the TCP messages.
        ReloadLast = true //Reload old configuration in case of (re)configuration failure? Default = true. If true the FailedConfiguration message will not to be sent.
    }
    +Messages = {
       Class = ReferenceContainer
       +PreConfiguration = { //Optional message to send before the configuration is applied.
           Class = Message
           Destination = StateMachine 
           Function = STOP
           Mode = ExpectsReply
       }
       +PostConfiguration = { //Optional message to send if the configuration was successfully applied.
           Class = Message
           Destination = StateMachine 
           Function = START
           Mode = ExpectsReply
       }
    }
}
+StateMachine = {
    Class = StateMachine
    +INITIAL = {
        Class = ReferenceContainer
        +START = {
            Class = StateMachineEvent
            NextState = "STATE1"
            NextStateError = "ERROR"
            Timeout = 0
            +ChangeToState1Msg = {
                Class = Message
                Destination = TestApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = State1
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = TestApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
    }
    +STATE1 = {
        Class = ReferenceContainer
        +GOTOSTATE2 = {
            Class = StateMachineEvent
            NextState = "STATE2"
            NextStateError = "ERROR"
            Timeout = 0
            +PrepareChangeToState2Msg = {
                Class = Message
                Destination = TestApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = State2
                }
            }
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = TestApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = TestApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
        +STOP = {
            Class = StateMachineEvent
            NextState = "STOPPED"
            NextStateError = "ERROR"
            Timeout = 0
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = TestApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
        }
        +ERROR = {
            Class = StateMachineEvent
            NextState = "ERROR"
            NextStateError = "ERROR"
        }
    }
    +STATE2 = {
        Class = ReferenceContainer
        +GOTOSTATE1 = {
            Class = StateMachineEvent
            NextState = "STATE1"
            NextStateError = "ERROR"
            Timeout = 0
            +PrepareChangeToState1Msg = {
                Class = Message
                Destination = TestApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = State1
                }
            }
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = TestApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = TestApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
        +STOP = {
            Class = StateMachineEvent
            NextState = "STOPPED"
            NextStateError = "ERROR"
            Timeout = 0
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = TestApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
        }
        +ERROR = {
            Class = StateMachineEvent
            NextState = "ERROR"
            NextStateError = "ERROR"
        }
    }
    +STOPPED = {
        Class = ReferenceContainer
        +START = {
            Class = StateMachineEvent
            NextState = "STATE1"
            NextStateError = "ERROR"
            Timeout = 0
            +ChangeToState1Msg = {
                Class = Message
                Destination = TestApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = State1
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = TestApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }

        }
    }
    +ERROR = {
        Class = ReferenceContainer
        +ENTER = {
            Class = ReferenceContainer
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = TestApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareChangeToErrorMsg = {
                Class = Message
                Destination = TestApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = StateError
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = TestApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
        +RESET = {
            Class = StateMachineEvent
            NextState = "STATE1"
            NextStateError = "STATE1"
            Timeout = 0
            +StopCurrentStateExecutionMsg = {
                Class = Message
                Destination = TestApp
                Function = StopCurrentStateExecution
                Mode = ExpectsReply
            }
            +PrepareChangeToState1Msg = {
                Class = Message
                Destination = TestApp
                Mode = ExpectsReply
                Function = PrepareNextState
                +Parameters = {
                    Class = ConfigurationDatabase
                    param1 = State1
                }
            }
            +StartNextStateExecutionMsg = {
                Class = Message
                Destination = TestApp
                Function = StartNextStateExecution
                Mode = ExpectsReply
            }
        }
    }
}
$TestApp = {
    Class = RealTimeApplication
    +Functions = {
        Class = ReferenceContainer
        +GAMTimer = {
            Class = IOGAM
            InputSignals = {
                Counter = {
                    DataSource = Timer
                    Type = uint32
                }
                Time = {
                    Frequency = 1
                    DataSource = Timer
                    Type = uint32
                }
            }
            OutputSignals = {
                Counter = {
                    DataSource = DDB1
                    Type = uint32
                }
                Time = {
                    DataSource = DDB1
                    Type = uint32
                }
            }
        }
        +GAMVariable1 = {
            Class = VariableGAMExample1
            Gains = {2, 3, 4}
            InputSignals = {
                Counter = {
                    DataSource = DDB1
                    Type = uint32
                }                
            }
            OutputSignals = {
                GainCounter1Thread1 = {
                    DataSource = DDB1
                    Type = uint32
                }
                GainCounter2Thread1 = {
                    DataSource = DDB1
                    Type = uint32
                }
                GainCounter3Thread1 = {
                    DataSource = DDB1
                    Type = uint32
                }                
            }
        }
        +GAMT1TSynchOut = {
            Class = IOGAM
            InputSignals = {
                GainCounter1Thread1 = {
                    DataSource = DDB1
                    Type = uint32
                }
                GainCounter2Thread1 = {
                    DataSource = DDB1
                    Type = uint32
                }
                GainCounter3Thread1 = {
                    DataSource = DDB1
                    Type = uint32
                }
            }
            OutputSignals = {
                GainCounter1Thread1 = {
                    DataSource = RTThreadSynch
                    Type = uint32
                }
                GainCounter2Thread1 = {
                    DataSource = RTThreadSynch
                    Type = uint32
                }
                GainCounter3Thread1 = {
                    DataSource = RTThreadSynch
                    Type = uint32
                }
            }
        }
        +GAMT1T2Interface = {
            Class = IOGAM
            InputSignals = {
                GainCounter1Thread1 = {
                    DataSource = RTThreadSynch
                    Type = uint32
                    Samples = 2 //Run at half the frequency of thread 1
                }
                GainCounter2Thread1 = {
                    DataSource = RTThreadSynch
                    Type = uint32
                    Samples = 2 //Run at half the frequency of thread 1
                }
                GainCounter3Thread1 = {
                    DataSource = RTThreadSynch
                    Type = uint32
                    Samples = 2 //Run at half the frequency of thread 1
                }
            }
            OutputSignals = {
                GainCounter1Thread2 = {
                    DataSource = DDB1
                    Type = uint32
                    Samples = 1
                    NumberOfDimensions = 1
                    NumberOfElements = 2 //2 elements for each cycle (as it waits for 2 samples)
                }
                GainCounter2Thread2 = {
                    DataSource = DDB1
                    Type = uint32
                    Samples = 1
                    NumberOfDimensions = 1
                    NumberOfElements = 2 //2 elements for each cycle (as it waits for 2 samples)
                }
                GainCounter3Thread2 = {
                    DataSource = DDB1
                    Type = uint32
                    Samples = 1
                    NumberOfDimensions = 1
                    NumberOfElements = 2 //2 elements for each cycle (as it waits for 2 samples)
                }
            }
        }
        +GAMT1T3Interface = {
            Class = IOGAM
            InputSignals = {
                GainCounter1Thread1 = {
                    DataSource = RTThreadSynch
                    Type = uint32
                    Samples = 4 //Run at one quarter of the frequency of thread 1
                }
                GainCounter2Thread1 = {
                    DataSource = RTThreadSynch
                    Type = uint32
                    Samples = 4 //Run at one quarter  the frequency of thread 1
                }
                GainCounter3Thread1 = {
                    DataSource = RTThreadSynch
                    Type = uint32
                    Samples = 4 //Run at one quarter  the frequency of thread 1
                }
            }
            OutputSignals = {
                GainCounter1Thread3 = {
                    DataSource = DDB1
                    Type = uint32
                    Samples = 1
                    NumberOfDimensions = 1
                    NumberOfElements = 4 //4 elements for each cycle (as it waits for 4 samples)
                }
                GainCounter2Thread3 = {
                    DataSource = DDB1
                    Type = uint32
                    Samples = 1
                    NumberOfDimensions = 1
                    NumberOfElements = 4 //4 elements for each cycle (as it waits for 4 samples)
                }
                GainCounter3Thread3 = {
                    DataSource = DDB1
                    Type = uint32
                    Samples = 1
                    NumberOfDimensions = 1
                    NumberOfElements = 4 //4 elements for each cycle (as it waits for 4 samples)
                }
            }
        }
        +GAMDisplayThread1 = {
            Class = IOGAM            
            InputSignals = {
                Counter = {
                    DataSource = DDB1
                    Type = uint32
                }
                GainCounter1Thread1 = {
                    DataSource = DDB1
                    Type = uint32
                }
                GainCounter2Thread1 = {
                    DataSource = DDB1
                    Type = uint32
                }
                GainCounter3Thread1 = {
                    DataSource = DDB1
                    Type = uint32
                }            
            }
            OutputSignals = {
                Counter = {
                    DataSource = LoggerDataSource
                    Type = uint32
                }
                GainCounter1Thread1 = {
                    DataSource = LoggerDataSource
                    Type = uint32
                }
                GainCounter2Thread1 = {
                    DataSource = LoggerDataSource
                    Type = uint32
                }
                GainCounter3Thread1 = {
                    DataSource = LoggerDataSource
                    Type = uint32
                }
            }
        }
        +GAMDisplayThread2 = {
            Class = IOGAM            
            InputSignals = {
                GainCounter1Thread2 = {
                    DataSource = DDB1
                    Type = uint32
                }
                GainCounter2Thread2 = {
                    DataSource = DDB1
                    Type = uint32
                }
                GainCounter3Thread2 = {
                    DataSource = DDB1
                    Type = uint32
                }            
            }
            OutputSignals = {
                GainCounter1Thread2 = {
                    DataSource = LoggerDataSource
                    Type = uint32
                    NumberOfDimensions = 1
                    NumberOfElements = 2
                }
                GainCounter2Thread2 = {
                    DataSource = LoggerDataSource
                    Type = uint32
                    NumberOfDimensions = 1
                    NumberOfElements = 2
                }
                GainCounter3Thread2 = {
                    DataSource = LoggerDataSource
                    Type = uint32
                    NumberOfDimensions = 1
                    NumberOfElements = 2
                }
            }
        }
        +GAMDisplayThread3 = {
            Class = IOGAM            
            InputSignals = {
                GainCounter1Thread3 = {
                    DataSource = DDB1
                    Type = uint32
                }
                GainCounter2Thread3 = {
                    DataSource = DDB1
                    Type = uint32
                }
                GainCounter3Thread3 = {
                    DataSource = DDB1
                    Type = uint32
                }            
            }
            OutputSignals = {
                GainCounter1Thread3 = {
                    DataSource = LoggerDataSource
                    Type = uint32
                    NumberOfDimensions = 1
                    NumberOfElements = 4
                }
                GainCounter2Thread3 = {
                    DataSource = LoggerDataSource
                    Type = uint32
                    NumberOfDimensions = 1
                    NumberOfElements = 4
                }
                GainCounter3Thread3 = {
                    DataSource = LoggerDataSource
                    Type = uint32
                    NumberOfDimensions = 1
                    NumberOfElements = 4
                }
            }
        }
    }
    +Data = {
        Class = ReferenceContainer
        DefaultDataSource = DDB1
        +DDB1 = {
            Class = GAMDataSource
        }
        +LoggerDataSource = {
            Class = LoggerDataSource
        }
        +Timings = {
            Class = TimingDataSource
        }
        +RTThreadSynch = {
            Class = RealTimeThreadSynchronisation
            Timeout = 5000 //Timeout in ms to wait for the thread to cycle.
        }
        +Timer = {
            Class = LinuxTimer
            SleepNature = "Default"
            Signals = {
                Counter = {
                    Type = uint32
                }
                Time = {
                    Type = uint32
                }
            }
        }
    }
    +States = {
        Class = ReferenceContainer
        +State1 = {
            Class = RealTimeState
            +Threads = {
                Class = ReferenceContainer
                +Thread1 = {
                    Class = RealTimeThread
                    CPUs = 0x1
                    Functions = {GAMTimer GAMVariable1 GAMT1TSynchOut GAMDisplayThread1}
                }
            }
        }
        +State2 = {
            Class = RealTimeState
            +Threads = {
                Class = ReferenceContainer
                +Thread1 = {
                    Class = RealTimeThread
                    CPUs = 0x1
                    Functions = {GAMTimer GAMVariable1 GAMT1TSynchOut GAMDisplayThread1}
                }
                +Thread2 = {
                    Class = RealTimeThread
                    CPUs = 0x2
                    Functions = {GAMT1T2Interface GAMDisplayThread2}
                }
                +Thread3 = {
                    Class = RealTimeThread
                    CPUs = 0x4
                    Functions = {GAMT1T3Interface GAMDisplayThread3}
                }
            }
        }
        +StateError = {
            Class = RealTimeState
            +Threads = {
                Class = ReferenceContainer
                +Thread1 = {
                    Class = RealTimeThread
                    CPUs = 0x1
                    Functions = {GAMTimer}
                }
            }
        }
    }
    +Scheduler = {
        Class = GAMScheduler
        TimingDataSource = Timings
    }
}

Invalid reconfiguration

Given that the application was launched with the parameter ReloadLast=true, a failed reconfiguration attempt will trigger the reloading of the last valid configuration.

To load an invalid configuration, start the application and, on another console, type nc localhost 24680 < RTApp-9-reload-fail.cfg. Notice that the application will continue to run at the original frequency.