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

    buffer_state = BUFFER_FREE;

    57

}

    58

    59

void __cleanup_debug()

    60

{

    61

}

    62

    63

void __retrieve_debug()

    64

{

    65

}

    66

    67

extern int TryEnterDebugSection(void);

    68

extern void LeaveDebugSection(void);

    69

    70

extern int __tick;

    71

void __publish_debug()

    72

{

    73

    /* Check there is no running debugger re-configuration */

    74

    if(TryEnterDebugSection()){

    75

        /* Lock buffer */

    76

        long latest_state = AtomicCompareExchange(

    77

            &buffer_state,

    78

            BUFFER_FREE,

    79

            BUFFER_BUSY);

    80

    81

        /* If buffer was free */

    82

        if(latest_state == BUFFER_FREE)

    83

        {

    84

            int* subscription;

    85

    86

            /* Reset buffer cursor */

    87

            buffer_cursor = debug_buffer;

    88

    89

            /* iterate over subscriptions */

    90

            for(subscription=subscription_table;

    91

                subscription < latest_subscription;

    92

                subscription++)

    93

            {

    94

                /* get variable descriptor */

    95

                struct_plcvar* my_var = &variable_table[*subscription];

    96

                char* next_cursor;

    97

                /* get variable size*/

    98

                USINT size = __get_type_enum_size(my_var->type);

    99

                /* compute next cursor positon*/

   100

                next_cursor = buffer_cursor + size;

   101

                /* if buffer not full */

   102

                if(next_cursor < debug_buffer + BUFFER_SIZE)

   103

                {

   104

                    /* copy data to the buffer */

   105

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

   106

                    /* increment cursor according size*/

   107

                    buffer_cursor = next_cursor;

   108

                }else{

   109

                    /*TODO : signal overflow*/

   110

                }

   111

            }

   112

   113

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

   114

            buffer_cursor = debug_buffer;

   115

            subscription_cursor = subscription_table;

   116

   117

            /* Leave debug section,

   118

             * Trigger asynchronous transmission 

   119

             * (returns immediately) */

   120

            InitiateDebugTransfer(); /* size */

   121

        }

   122

        LeaveDebugSection();

   123

    }

   124

}

   125

   126

void RegisterDebugVariable(int idx)

   127

{

   128

    /*If subscription table not full */

   129

    if(latest_subscription - subscription_table < MAX_SUBSCRIBTION)

   130

    {

   131

        *(latest_subscription++) = idx;

   132

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

   133

    }else{

   134

        /*TODO : signal subscription overflow*/

   135

    }

   136

}

   137

   138

void ResetDebugVariables(void)

   139

{

   140

    latest_subscription = subscription_table;

   141

}

   142

   143

void FreeDebugData()

   144

{

   145

    /* atomically mark buffer as free */

   146

    long latest_state = AtomicCompareExchange(

   147

        &buffer_state,

   148

        BUFFER_BUSY,

   149

        BUFFER_FREE);

   150

}

   151

   152

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

   153

{

   154

    if(subscription_cursor < latest_subscription){

   155

        char* old_cursor = buffer_cursor;

   156

        *idx = *subscription_cursor;

   157

        struct_plcvar* my_var = &variable_table[*(subscription_cursor++)];

   158

        *type_name = __get_type_enum_name(my_var->type);

   159

        /* get variable size*/

   160

        USINT size = __get_type_enum_size(my_var->type);

   161

        /* compute next cursor positon*/

   162

        buffer_cursor = buffer_cursor + size;

   163

        if(old_cursor < debug_buffer + BUFFER_SIZE)

   164

        {

   165

            return old_cursor;

   166

        }else{

   167

            return NULL;

   168

        } 

   169

    }

   170

    *idx = -1;

   171

    *type_name = NULL;

   172

    return NULL;

   173

}

   174