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

#include <stdio.h>

    18

    19

#define BUFFER_SIZE %(buffer_size)d

    20

#define MAX_SUBSCRIBTION %(subscription_table_count)d

    21

    22

/* Atomically accessed variable for buffer state */

    23

#define BUFFER_FREE 0

    24

#define BUFFER_BUSY 1

    25

static long buffer_state = BUFFER_FREE;

    26

    27

/* The buffer itself */

    28

char debug_buffer[BUFFER_SIZE];

    29

    30

/* Buffer's cursor*/

    31

static char* buffer_cursor = debug_buffer;

    32

    33

typedef struct{

    34

    void* ptrvalue;

    35

    __IEC_types_enum type;

    36

}struct_plcvar;

    37

    38

/***

    39

 * Declare programs 

    40

 **/

    41

%(programs_declarations)s

    42

    43

/***

    44

 * Declare global variables from resources and conf 

    45

 **/

    46

%(extern_variables_declarations)s

    47

    48

static int subscription_table[MAX_SUBSCRIBTION];

    49

static int* latest_subscription = subscription_table;

    50

static int* subscription_cursor = subscription_table;

    51

    52

struct_plcvar variable_table[%(variables_pointer_type_table_count)d];

    53

    54

void __init_debug()

    55

{

    56

%(variables_pointer_type_table_initializer)s

    57

    buffer_state = BUFFER_FREE;

    58

}

    59

    60

void __cleanup_debug()

    61

{

    62

}

    63

    64

void __retrieve_debug()

    65

{

    66

}

    67

    68

extern int TryEnterDebugSection(void);

    69

extern void LeaveDebugSection(void);

    70

extern long AtomicCompareExchange(long*, long, long);

    71

extern void InitiateDebugTransfer(void);

    72

    73

extern int __tick;

    74

void __publish_debug()

    75

{

    76

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

    77

    if(TryEnterDebugSection()){

    78

        /* Lock buffer */

    79

        long latest_state = AtomicCompareExchange(

    80

            &buffer_state,

    81

            BUFFER_FREE,

    82

            BUFFER_BUSY);

    83

    84

        /* If buffer was free */

    85

        if(latest_state == BUFFER_FREE)

    86

        {

    87

            int* subscription;

    88

    89

            /* Reset buffer cursor */

    90

            buffer_cursor = debug_buffer;

    91

    92

            /* iterate over subscriptions */

    93

            for(subscription=subscription_table;

    94

                subscription < latest_subscription;

    95

                subscription++)

    96

            {

    97

                /* get variable descriptor */

    98

                struct_plcvar* my_var = &variable_table[*subscription];

    99

                char* next_cursor;

   100

                /* get variable size*/

   101

                USINT size = __get_type_enum_size(my_var->type);

   102

                /* compute next cursor positon*/

   103

                next_cursor = buffer_cursor + size;

   104

                /* if buffer not full */

   105

                if(next_cursor < debug_buffer + BUFFER_SIZE)

   106

                {

   107

                    /* copy data to the buffer */

   108

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

   109

                    /* increment cursor according size*/

   110

                    buffer_cursor = next_cursor;

   111

                }else{

   112

                    /*TODO : signal overflow*/

   113

                }

   114

            }

   115

   116

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

   117

            buffer_cursor = debug_buffer;

   118

            subscription_cursor = subscription_table;

   119

   120

            /* Leave debug section,

   121

             * Trigger asynchronous transmission 

   122

             * (returns immediately) */

   123

            InitiateDebugTransfer(); /* size */

   124

        }

   125

        LeaveDebugSection();

   126

    }

   127

}

   128

   129

void RegisterDebugVariable(int idx)

   130

{

   131

    /*If subscription table not full */

   132

    if(latest_subscription - subscription_table < MAX_SUBSCRIBTION)

   133

    {

   134

        *(latest_subscription++) = idx;

   135

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

   136

    }else{

   137

        /*TODO : signal subscription overflow*/

   138

    }

   139

}

   140

   141

void ResetDebugVariables(void)

   142

{

   143

    latest_subscription = subscription_table;

   144

}

   145

   146

void FreeDebugData()

   147

{

   148

    /* atomically mark buffer as free */

   149

    long latest_state = AtomicCompareExchange(

   150

        &buffer_state,

   151

        BUFFER_BUSY,

   152

        BUFFER_FREE);

   153

}

   154

   155

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

   156

{

   157

	struct_plcvar* my_var;

   158

	USINT size;

   159

    if(subscription_cursor < latest_subscription){

   160

        char* old_cursor = buffer_cursor;

   161

        *idx = *subscription_cursor;

   162

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

   163

        *type_name = __get_type_enum_name(my_var->type);

   164

        /* get variable size*/

   165

        size = __get_type_enum_size(my_var->type);

   166

        /* compute next cursor position*/

   167

        buffer_cursor = buffer_cursor + size;

   168

        if(old_cursor < debug_buffer + BUFFER_SIZE)

   169

        {

   170

            return old_cursor;

   171

        }else{

   172

            printf("%%d > %%d\n", old_cursor - debug_buffer, BUFFER_SIZE);

   173

	    return NULL;

   174

        } 

   175

    }

   176

    *idx = -1;

   177

    *type_name = NULL;

   178

    return NULL;

   179

}

   180