1 /*

     2  * DEBUGGER code

     3  * 

     4  * On "publish", when buffer is free, debugger stores arbitrary variables 

     5  * content into, and mark this buffer as filled

     6  * 

     7  * 

     8  * Buffer content is read asynchronously, (from non real time part), 

     9  * and then buffer marked free again.

    10  *  

    11  * 

    12  * */

    13 #include "iec_types_all.h"

    14 #include "POUS.h"

    15 /*for memcpy*/

    16 #include <string.h>

    17 

    18 #define BUFFER_SIZE 1024

    19 #define MAX_SUBSCRIBTION %(subscription_table_count)d

    20 

    21 /* Atomically accessed variable for buffer state */

    22 #define BUFFER_FREE 0

    23 #define BUFFER_BUSY 1

    24 static long buffer_state = BUFFER_FREE;

    25 

    26 /* The buffer itself */

    27 char debug_buffer[BUFFER_SIZE];

    28 

    29 /* Buffer's cursor*/

    30 static char* buffer_cursor = debug_buffer;

    31 

    32 typedef struct{

    33     void* ptrvalue;

    34     __IEC_types_enum type;

    35 }struct_plcvar;

    36 

    37 /***

    38  * Declare programs 

    39  **/

    40 %(programs_declarations)s

    41 

    42 /***

    43  * Declare global variables from resources and conf 

    44  **/

    45 %(extern_variables_declarations)s

    46 

    47 static int subscription_table[MAX_SUBSCRIBTION];

    48 static int* latest_subscription = subscription_table;

    49 static int* subscription_cursor = subscription_table;

    50 

    51 struct_plcvar variable_table[%(variables_pointer_type_table_count)d];

    52 

    53 void __init_debug()

    54 {

    55 %(variables_pointer_type_table_initializer)s

    56 };

    57 

    58 void __cleanup_debug()

    59 {

    60 }

    61 

    62 void __retrieve_debug()

    63 {

    64 }

    65 

    66 void __publish_debug()

    67 {

    68     /* Lock buffer */

    69     long latest_state = AtomicCompareExchange(

    70         &buffer_state,

    71         BUFFER_FREE,

    72         BUFFER_BUSY);

    73         

    74     /* If buffer was free */

    75     if(latest_state == BUFFER_FREE)

    76     {

    77         int* subscription;

    78         

    79         /* Reset buffer cursor */

    80         buffer_cursor = debug_buffer;

    81         

    82         /* iterate over subscriptions */

    83         for(subscription=subscription_table;

    84             subscription < latest_subscription;

    85             subscription++)

    86         {

    87             /* get variable descriptor */

    88             struct_plcvar* my_var = &variable_table[*subscription];

    89             char* next_cursor;

    90             /* get variable size*/

    91             USINT size = __get_type_enum_size(my_var->type);

    92             /* compute next cursor positon*/

    93             next_cursor = buffer_cursor + size;

    94             /* if buffer not full */

    95             if(next_cursor < debug_buffer + BUFFER_SIZE)

    96             {

    97                 /* copy data to the buffer */

    98                 memcpy(buffer_cursor, my_var->ptrvalue, size);

    99                 /* increment cursor according size*/

   100                 buffer_cursor = next_cursor;

   101             }else{

   102                 /*TODO : signal overflow*/

   103             }

   104         }

   105 

   106         /* Reset buffer cursor again (for IterDebugData)*/

   107         buffer_cursor = debug_buffer;

   108         subscription_cursor = subscription_table;

   109         

   110         /* Trigger asynchronous transmission (returns immediately) */

   111         InitiateDebugTransfer(); /* size */

   112     }

   113 }

   114 

   115 void RegisterDebugVariable(int idx)

   116 {

   117     /*If subscription table not full */

   118     if(latest_subscription - subscription_table < MAX_SUBSCRIBTION)

   119     {

   120         *(latest_subscription++) = idx;

   121         /* TODO pre-calc buffer size and signal overflow*/

   122     }else{

   123         /*TODO : signal subscription overflow*/

   124     }

   125 }

   126 

   127 void ResetDebugVariables(void)

   128 {

   129     latest_subscription = subscription_table;

   130 }

   131 

   132 void FreeDebugData()

   133 {

   134     /* atomically mark buffer as free */

   135     long latest_state = AtomicCompareExchange(

   136         &buffer_state,

   137         BUFFER_BUSY,

   138         BUFFER_FREE);

   139 }

   140 

   141 void* IterDebugData(int* idx, const char **type_name)

   142 {

   143     if(subscription_cursor < latest_subscription){

   144         *idx = *subscription_cursor;

   145         struct_plcvar* my_var = &variable_table[*subscription_cursor++];

   146         *type_name = __get_type_enum_name(my_var->type);

   147         return my_var->ptrvalue;

   148     }

   149     return NULL;

   150 }

   151