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

    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

static unsigned int retain_offset = 0;

    32

/***

    33

 * Declare programs 

    34

 **/

    35

%(programs_declarations)s

    36

    37

/***

    38

 * Declare global variables from resources and conf 

    39

 **/

    40

%(extern_variables_declarations)s

    41

    42

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

    43

void __for_each_variable_do(__for_each_variable_do_fp fp)

    44

{

    45

%(for_each_variable_do_code)s

    46

}

    47

    48

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

    49

{

    50

    switch(varindex){

    51

%(find_variable_case_code)s

    52

     default:

    53

      *varp = NULL;

    54

      return UNKNOWN_ENUM;

    55

    }

    56

}

    57

    58

#define __Unpack_case_t(TYPENAME) \

    59

        case TYPENAME##_ENUM :\

    60

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

    61

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

    62

            break;

    63

    64

#define __Unpack_case_p(TYPENAME)\

    65

        case TYPENAME##_O_ENUM :\

    66

            *flags = __IEC_OUTPUT_FLAG;\

    67

        case TYPENAME##_P_ENUM :\

    68

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

    69

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

    70

            forced_value_p = &((__IEC_##TYPENAME##_p *)varp)->fvalue;\

    71

            break;

    72

    73

void* UnpackVar(void* varp, __IEC_types_enum vartype, void **real_value_p, char *flags)

    74

{

    75

    void *forced_value_p = NULL;

    76

    *flags = 0;

    77

    /* find data to copy*/

    78

    switch(vartype){

    79

        __ANY(__Unpack_case_t)

    80

        __ANY(__Unpack_case_p)

    81

    default:

    82

        break;

    83

    }

    84

    if (*flags & __IEC_FORCE_FLAG)

    85

        return forced_value_p;

    86

    return *real_value_p;

    87

}

    88

    89

void Remind(unsigned int offset, unsigned int count, void * p);

    90

    91

void RemindIterator(void* varp, __IEC_types_enum vartype)

    92

{

    93

    void *real_value_p = NULL;

    94

    char flags = 0;

    95

    UnpackVar(varp, vartype, &real_value_p, &flags);

    96

    97

    if(flags & __IEC_RETAIN_FLAG){

    98

        USINT size = __get_type_enum_size(vartype);

    99

        /* compute next cursor positon*/

   100

        unsigned int next_retain_offset = retain_offset + size;

   101

        /* if buffer not full */

   102

        Remind(retain_offset, size, real_value_p);

   103

        /* increment cursor according size*/

   104

        retain_offset = next_retain_offset;

   105

    }

   106

}

   107

   108

extern int CheckRetainBuffer(void);

   109

   110

void __init_debug(void)

   111

{

   112

    /* init local static vars */

   113

    buffer_cursor = debug_buffer;

   114

    retain_offset = 0;

   115

    buffer_state = BUFFER_FREE;

   116

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

   117

    if(CheckRetainBuffer())

   118

    	__for_each_variable_do(RemindIterator);

   119

    retain_offset = 0;

   120

}

   121

   122

extern void InitiateDebugTransfer(void);

   123

   124

extern unsigned long __tick;

   125

   126

void __cleanup_debug(void)

   127

{

   128

    buffer_cursor = debug_buffer;

   129

    InitiateDebugTransfer();

   130

}

   131

   132

void __retrieve_debug(void)

   133

{

   134

}

   135

   136

   137

void Retain(unsigned int offset, unsigned int count, void * p);

   138

   139

inline void BufferIterator(void* varp, __IEC_types_enum vartype, int do_debug)

   140

{

   141

    void *real_value_p = NULL;

   142

    void *visible_value_p = NULL;

   143

    char flags = 0;

   144

   145

    visible_value_p = UnpackVar(varp, vartype, &real_value_p, &flags);

   146

   147

    if(flags & ( __IEC_DEBUG_FLAG | __IEC_RETAIN_FLAG)){

   148

        USINT size = __get_type_enum_size(vartype);

   149

        if(flags & __IEC_DEBUG_FLAG){

   150

            /* copy visible variable to buffer */;

   151

            if(do_debug){

   152

                /* compute next cursor positon.

   153

                   No need to check overflow, as BUFFER_SIZE

   154

                   is computed large enough */

   155

                char* next_cursor = buffer_cursor + size;

   156

                /* copy data to the buffer */

   157

                memcpy(buffer_cursor, visible_value_p, size);

   158

                /* increment cursor according size*/

   159

                buffer_cursor = next_cursor;

   160

            }

   161

            /* re-force real value of outputs (M and Q)*/

   162

            if((flags & __IEC_FORCE_FLAG) && (flags & __IEC_OUTPUT_FLAG)){

   163

                memcpy(real_value_p, visible_value_p, size);

   164

            }

   165

        }

   166

        if(flags & __IEC_RETAIN_FLAG){

   167

            /* compute next cursor positon*/

   168

            unsigned int next_retain_offset = retain_offset + size;

   169

            /* if buffer not full */

   170

            Retain(retain_offset, size, real_value_p);

   171

            /* increment cursor according size*/

   172

            retain_offset = next_retain_offset;

   173

        }

   174

    }

   175

}

   176

   177

void DebugIterator(void* varp, __IEC_types_enum vartype){

   178

    BufferIterator(varp, vartype, 1);

   179

}

   180

   181

void RetainIterator(void* varp, __IEC_types_enum vartype){

   182

    BufferIterator(varp, vartype, 0);

   183

}

   184

   185

extern int TryEnterDebugSection(void);

   186

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

   187

extern void LeaveDebugSection(void);

   188

extern void ValidateRetainBuffer(void);

   189

extern void InValidateRetainBuffer(void);

   190

   191

void __publish_debug(void)

   192

{

   193

    retain_offset = 0;

   194

    InValidateRetainBuffer();

   195

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

   196

    if(TryEnterDebugSection()){

   197

        /* Lock buffer */

   198

        long latest_state = AtomicCompareExchange(

   199

            &buffer_state,

   200

            BUFFER_FREE,

   201

            BUFFER_BUSY);

   202

   203

        /* If buffer was free */

   204

        if(latest_state == BUFFER_FREE)

   205

        {

   206

            /* Reset buffer cursor */

   207

            buffer_cursor = debug_buffer;

   208

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

   209

            __for_each_variable_do(DebugIterator);

   210

   211

            /* Leave debug section,

   212

             * Trigger asynchronous transmission 

   213

             * (returns immediately) */

   214

            InitiateDebugTransfer(); /* size */

   215

        }else{

   216

            /* when not debugging, do only retain */

   217

            __for_each_variable_do(RetainIterator);

   218

        }

   219

        LeaveDebugSection();

   220

    }else{

   221

        /* when not debugging, do only retain */

   222

        __for_each_variable_do(RetainIterator);

   223

    }

   224

    ValidateRetainBuffer();

   225

}

   226

   227

#define __RegisterDebugVariable_case_t(TYPENAME) \

   228

        case TYPENAME##_ENUM :\

   229

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

   230

            if(force)\

   231

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

   232

            break;

   233

#define __RegisterDebugVariable_case_p(TYPENAME)\

   234

        case TYPENAME##_P_ENUM :\

   235

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

   236

            if(force)\

   237

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

   238

            break;\

   239

        case TYPENAME##_O_ENUM :\

   240

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

   241

            if(force){\

   242

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

   243

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

   244

            }\

   245

            break;

   246

void RegisterDebugVariable(int idx, void* force)

   247

{

   248

    void *varp = NULL;

   249

    unsigned char flags = force ? __IEC_DEBUG_FLAG | __IEC_FORCE_FLAG : __IEC_DEBUG_FLAG;

   250

    switch(__find_variable(idx, &varp)){

   251

        __ANY(__RegisterDebugVariable_case_t)

   252

        __ANY(__RegisterDebugVariable_case_p)

   253

    default:

   254

        break;

   255

    }

   256

}

   257

   258

#define __ResetDebugVariablesIterator_case_t(TYPENAME) \

   259

        case TYPENAME##_ENUM :\

   260

            ((__IEC_##TYPENAME##_t *)varp)->flags &= ~(__IEC_DEBUG_FLAG|__IEC_FORCE_FLAG);\

   261

            break;

   262

   263

#define __ResetDebugVariablesIterator_case_p(TYPENAME)\

   264

        case TYPENAME##_P_ENUM :\

   265

        case TYPENAME##_O_ENUM :\

   266

            ((__IEC_##TYPENAME##_p *)varp)->flags &= ~(__IEC_DEBUG_FLAG|__IEC_FORCE_FLAG);\

   267

            break;

   268

   269

void ResetDebugVariablesIterator(void* varp, __IEC_types_enum vartype)

   270

{

   271

    /* force debug flag to 0*/

   272

    switch(vartype){

   273

        __ANY(__ResetDebugVariablesIterator_case_t)

   274

        __ANY(__ResetDebugVariablesIterator_case_p)

   275

    default:

   276

        break;

   277

    }

   278

}

   279

   280

void ResetDebugVariables(void)

   281

{

   282

    __for_each_variable_do(ResetDebugVariablesIterator);

   283

}

   284

   285

void FreeDebugData(void)

   286

{

   287

    /* atomically mark buffer as free */

   288

    long latest_state;

   289

    latest_state = AtomicCompareExchange(

   290

        &buffer_state,

   291

        BUFFER_BUSY,

   292

        BUFFER_FREE);

   293

}

   294

int WaitDebugData(unsigned long *tick);

   295

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

   296

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

   297

    int wait_error = WaitDebugData(tick);

   298

    if(!wait_error){

   299

        *size = buffer_cursor - debug_buffer;

   300

        *buffer = debug_buffer;

   301

    }

   302

    return wait_error;

   303

}

   304