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

/***

    34

 * Declare programs 

    35

 **/

    36

%(programs_declarations)s

    37

    38

/***

    39

 * Declare global variables from resources and conf 

    40

 **/

    41

%(extern_variables_declarations)s

    42

    43

typedef void(*__for_each_variable_do_fp)(void*, __IEC_types_enum);

    44

void __for_each_variable_do(__for_each_variable_do_fp fp)

    45

{

    46

%(for_each_variable_do_code)s

    47

}

    48

    49

__IEC_types_enum __find_variable(unsigned int varindex, void ** varp)

    50

{

    51

    switch(varindex){

    52

%(find_variable_case_code)s

    53

     default:

    54

      *varp = NULL;

    55

      return UNKNOWN_ENUM;

    56

    }

    57

}

    58

    59

void __init_debug(void)

    60

{

    61

    buffer_state = BUFFER_FREE;

    62

}

    63

    64

void __cleanup_debug(void)

    65

{

    66

}

    67

    68

void __retrieve_debug(void)

    69

{

    70

}

    71

    72

extern int TryEnterDebugSection(void);

    73

extern void LeaveDebugSection(void);

    74

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

    75

extern void InitiateDebugTransfer(void);

    76

    77

extern unsigned long __tick;

    78

    79

#define __BufferDebugDataIterator_case_t(TYPENAME) \

    80

        case TYPENAME##_ENUM :\

    81

            flags = ((__IEC_##TYPENAME##_t *)varp)->flags;\

    82

            ptrvalue = &((__IEC_##TYPENAME##_t *)varp)->value;\

    83

            break;

    84

    85

#define __BufferDebugDataIterator_case_p(TYPENAME)\

    86

        case TYPENAME##_P_ENUM :\

    87

            flags = ((__IEC_##TYPENAME##_p *)varp)->flags;\

    88

            ptrvalue = ((__IEC_##TYPENAME##_p *)varp)->value;\

    89

            break;

    90

    91

void BufferDebugDataIterator(void* varp, __IEC_types_enum vartype)

    92

{

    93

    void *ptrvalue = NULL;

    94

    char flags = 0;

    95

    /* find data to copy*/

    96

    switch(vartype){

    97

        ANY(__BufferDebugDataIterator_case_t)

    98

        ANY(__BufferDebugDataIterator_case_p)

    99

    default:

   100

        break;

   101

    }

   102

    if(flags && __IEC_DEBUG_FLAG){

   103

        USINT size = __get_type_enum_size(vartype);

   104

        /* compute next cursor positon*/

   105

        char* next_cursor = buffer_cursor + size;

   106

        /* if buffer not full */

   107

        if(next_cursor <= debug_buffer + BUFFER_SIZE)

   108

        {

   109

            /* copy data to the buffer */

   110

            memcpy(buffer_cursor, ptrvalue, size);

   111

            /* increment cursor according size*/

   112

            buffer_cursor = next_cursor;

   113

        }else{

   114

            /*TODO : signal overflow*/

   115

        }

   116

    }

   117

}

   118

   119

   120

void __publish_debug(void)

   121

{

   122

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

   123

    if(TryEnterDebugSection()){

   124

        /* Lock buffer */

   125

        long latest_state = AtomicCompareExchange(

   126

            &buffer_state,

   127

            BUFFER_FREE,

   128

            BUFFER_BUSY);

   129

   130

        /* If buffer was free */

   131

        if(latest_state == BUFFER_FREE)

   132

        {

   133

            /* Reset buffer cursor */

   134

            buffer_cursor = debug_buffer;

   135

            /* Iterate over all variables to fill debug buffer */

   136

            __for_each_variable_do(BufferDebugDataIterator);

   137

   138

            /* Leave debug section,

   139

             * Trigger asynchronous transmission 

   140

             * (returns immediately) */

   141

            InitiateDebugTransfer(); /* size */

   142

        }

   143

        LeaveDebugSection();

   144

    }

   145

}

   146

   147

#define __RegisterDebugVariable_case_t(TYPENAME) \

   148

        case TYPENAME##_ENUM :\

   152

            break;

   153

#define __RegisterDebugVariable_case_p(TYPENAME)\

   154

        case TYPENAME##_P_ENUM :\

   160

{

   161

    void *varp = NULL;

   163

    switch(__find_variable(idx, &varp)){

   164

        ANY(__RegisterDebugVariable_case_t)

   165

        ANY(__RegisterDebugVariable_case_p)

   166

    default:

   167

        break;

   168

    }

   169

}

   170

   171

#define __ResetDebugVariablesIterator_case_t(TYPENAME) \

   172

        case TYPENAME##_ENUM :\

   174

            break;

   175

   176

#define __ResetDebugVariablesIterator_case_p(TYPENAME)\

   177

        case TYPENAME##_P_ENUM :\

   179

            break;

   180

   181

void ResetDebugVariablesIterator(void* varp, __IEC_types_enum vartype)

   182

{

   183

    /* force debug flag to 0*/

   184

    switch(vartype){

   185

        ANY(__ResetDebugVariablesIterator_case_t)

   186

        ANY(__ResetDebugVariablesIterator_case_p)

   187

    default:

   188

        break;

   189

    }

   190

}

   191

   192

void ResetDebugVariables(void)

   193

{

   194

    __for_each_variable_do(ResetDebugVariablesIterator);

   195

}

   196

   197

void FreeDebugData(void)

   198

{

   199

    /* atomically mark buffer as free */

   200

    long latest_state;

   201

    latest_state = AtomicCompareExchange(

   202

        &buffer_state,

   203

        BUFFER_BUSY,

   204

        BUFFER_FREE);

   205

}

   206

int WaitDebugData(unsigned long *tick);

   207

/* Wait until debug data ready and return pointer to it */

   208

int GetDebugData(unsigned long *tick, unsigned long *size, void **buffer){

   209

    int res = WaitDebugData(tick);

   210

    *size = buffer_cursor - debug_buffer;

   211

    *buffer = debug_buffer;

   212

    return res;

   213

}

   214