Autosar Software Component

Question

I have reading several AUTOSAR Documents. For now, my concern is just developing Software Component. I have two software component designs, take a look to the picture below.

Explanation:

1. I got a data from port 1 and 2. Each of ports will correspondence with RunnableEntity which running when a new data has come. Then, the RunnableEntity sets that data to InterRunnableVariable. The main RunnableEntity which is RunnableEntity 1　will process the InterRunnableVariable to make an output.
2. The data freely come to the port and waiting to be proceed in the buffer. Then, The only one RunnableEntity will process the data with some help by common global variable (The purpose of global variable is same with InterRunnableVariable).

My questions are,

1. Will design 1 and 2 work?
2. If design 1 and 2 are true, which one do you prefer according the time process, time to implement, etc.?
3. Are the codes right? how to handle event and InterRunnableVariable?

Thank you for your help.

====================Adding Code After Comment========================

Design 1

/* Runnable Entity 1*/
/* Event : TimeEvent 25ms */
void re1(void){
    data_output out;
    irv irv1 = Rte_IrvIread_re1_irv1(); 
    irv irv2 = Rte_IrvIread_re1_irv2();
    irv irv3 = Rte_IrvIread_re1_irv3();

    out = DataProcess(&irv1,&irv2,&irv3);

    Rte_Write_re1_port3_out();
}

/* Runnable Entity 2*/
/* Event : DataReceiveErrorEvent on port1 */
void re2(void){     
    irv irv2 = Rte_IrvIread_re1_irv2();

    modify(&irv2);

    Rte_IrvIwrite_re1_irv2(irv2);
}

/* Runnable Entity 3*/
/* Event : DataReceiveEvent on port1 */
void re2(void){
    data_input1 in;
    Std_RetrunType status;

    irv irv1 = Rte_IrvIread_re1_irv1(); 
    status = Rte_Receive_re1_port1_input(&in);
    if (status == RTE_E_OK) {
        modify(&irv1,in);
        Rte_IrvIwrite_re1_irv1(irv1);
    }
}

/* Runnable Entity 4*/
/* Event : DataReceiveEvent on port2 */
void re2(void){
    data_input2 in;
    Std_RetrunType status;

    irv irv3 = Rte_IrvIread_re1_irv3(); 
    status = Rte_Receive_re1_port2_input2(&in);
    if (status == RTE_E_OK) {
        modify(&irv3,in2);
        Rte_IrvIwrite_re1_irv3(irv3);
    }
}

Design 2

/*Global Variable*/
global_variable1 gvar1; /* Equal with InterVariable 1 in Design 1*/
global_variable2 gvar2; /* Equal with InterVariable 2 in Design 1*/
global_variable3 gvar3; /* Equal with InterVariable 3 in Design 1*/

/* Runnable Entity 1*/
/* Event : TimeEvent 25ms */
void re1(void){
    data_output out;
    GetData1()
    GetData2()


    out = GetOutputWithGlobalVariable();

    Rte_Write_re1_port3_out(out);
}

/* Get Data 1*/
void getData1(){    
    Std_ReturnType status;　/* uint8  */
    data_input1 in;

    do {
        status = Rte_Receive_re1_port1_input1(&in);
        if (status == RTE_E_OK) {
            modifyGlobalVariable(in);
        }
    } while (status != RTE_E_NO_DATA && status != RTE_E_LOST_DATA);

    if(status != RTE_E_LOST_DATA){
        modifyGlobalVariableWhenError();
    }
    return;
}

/* Get Data 2*/
void getData2(){    
    Std_ReturnType status;　/* uint8  */
    data_input2 in;

    do {
        status = Rte_Receive_re1_port2_input2(&in);
        if (_status == RTE_E_OK) {
            modifyGlobalVariable2(in);
        }
    } while (status != RTE_E_NO_DATA && status != RTE_E_LOST_DATA);

    return;
}

Answer 1

I think both solutions are possible. The main difference is that in the first solution the generated Rte will manage the global buffer whereas in the second design, you have to take care of the buffers yourself. Especially if you have multiple runnables accessing the same buffer, the 'Rte' will either generate interrupt locks to protected data consistency or it will optimize out the locks if the task context in that the ´RunnableEntities´ are running cannot interrupt each other.

Even if you have only one ´RunnableEntity´ as shown in the second design, it might happen that the ´TimingEvent´ activates the ´RunnableEntity´ and the DataReceivedEvent as well (although I don't understand why you left out the DataReceivedEvent in the second design). In this case the ´RunnableEntity´ is running in two different contexts accessing the same data.

To make it short: My proposal is to use interrunnable variables and let the Rte handle the data consistency, initialization etc. It might be a little bit more effort to create the software component description, but then you just need to use the generated IrvRead/IrvWrite functions and you are done.