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 const struct {

    43

    void *ptr;

    44

    __IEC_types_enum type;

    45

} dbgvardsc_t;

    46

    47

static dbgvardsc_t dbgvardsc[] = {

    48

%(variable_decl_array)s

    49

};

    50

    51

typedef void(*__for_each_variable_do_fp)(dbgvardsc_t*);

    52

void __for_each_variable_do(__for_each_variable_do_fp fp)

    53

{

    54

    int i;

    55

    for(i = 0; i < sizeof(dbgvardsc)/sizeof(dbgvardsc_t); i++){

    56

        dbgvardsc_t *dsc = &dbgvardsc[i];

    57

        if(dsc->type != UNKNOWN_ENUM) 

    58

            (*fp)(dsc);

    59

    }

    60

}

    61

    62

#define __Unpack_case_t(TYPENAME) \

    63

        case TYPENAME##_ENUM :\

    64

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

    65

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

    66

            break;

    67

    68

#define __Unpack_case_p(TYPENAME)\

    69

        case TYPENAME##_O_ENUM :\

    70

            *flags = __IEC_OUTPUT_FLAG;\

    71

        case TYPENAME##_P_ENUM :\

    72

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

    73

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

    74

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

    75

            break;

    76

    77

void* UnpackVar(dbgvardsc_t *dsc, void **real_value_p, char *flags)

    78

{

    79

    void *varp = dsc->ptr;

    80

    void *forced_value_p = NULL;

    81

    *flags = 0;

    82

    /* find data to copy*/

    83

    switch(dsc->type){

    84

        __ANY(__Unpack_case_t)

    85

        __ANY(__Unpack_case_p)

    86

    default:

    87

        break;

    88

    }

    89

    if (*flags & __IEC_FORCE_FLAG)

    90

        return forced_value_p;

    91

    return *real_value_p;

    92

}

    93

    94

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

    95

    96

void RemindIterator(dbgvardsc_t *dsc)

    97

{

    98

    void *real_value_p = NULL;

    99

    char flags = 0;

   100

    UnpackVar(dsc, &real_value_p, &flags);

   101

   102

    if(flags & __IEC_RETAIN_FLAG){

   103

        USINT size = __get_type_enum_size(dsc->type);

   104

        /* compute next cursor positon*/

   105

        unsigned int next_retain_offset = retain_offset + size;

   106

        /* if buffer not full */

   107

        Remind(retain_offset, size, real_value_p);

   108

        /* increment cursor according size*/

   109

        retain_offset = next_retain_offset;

   110

    }

   111

}

   112

   113

extern int CheckRetainBuffer(void);

   114

extern void InitRetain(void);

   115

   116

void __init_debug(void)

   117

{

   118

    /* init local static vars */

   119

    buffer_cursor = debug_buffer;

   120

    retain_offset = 0;

   121

    buffer_state = BUFFER_FREE;

   122

    InitRetain();

   123

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

   124

    if(CheckRetainBuffer()){

   125

    	__for_each_variable_do(RemindIterator);

   126

    }else{

   127

    	char mstr[] = "RETAIN memory invalid - defaults used";

   128

        LogMessage(LOG_WARNING, mstr, sizeof(mstr));

   129

    }

   130

    retain_offset = 0;

   131

}

   132

   133

extern void InitiateDebugTransfer(void);

   134

extern void CleanupRetain(void);

   135

   136

extern unsigned long __tick;

   137

   138

void __cleanup_debug(void)

   139

{

   140

    buffer_cursor = debug_buffer;

   141

    InitiateDebugTransfer();

   142

    CleanupRetain();

   143

}

   144

   145

void __retrieve_debug(void)

   146

{

   147

}

   148

   149

   150

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

   151

   152

static inline void BufferIterator(dbgvardsc_t *dsc, int do_debug)

   153

{

   154

    void *real_value_p = NULL;

   155

    void *visible_value_p = NULL;

   156

    char flags = 0;

   157

   158

    visible_value_p = UnpackVar(dsc, &real_value_p, &flags);

   159

   160

    if(flags & ( __IEC_DEBUG_FLAG | __IEC_RETAIN_FLAG)){

   161

        USINT size = __get_type_enum_size(dsc->type);

   162

        if(flags & __IEC_DEBUG_FLAG){

   163

            /* copy visible variable to buffer */;

   164

            if(do_debug){

   165

                /* compute next cursor positon.

   166

                   No need to check overflow, as BUFFER_SIZE

   167

                   is computed large enough */

   168

		if((dsc->type == STRING_ENUM)   ||

   169

		   (dsc->type == STRING_P_ENUM) ||

   170

		   (dsc->type == STRING_O_ENUM)){

   171

                    /* optimization for strings */

   172

                    size = ((STRING*)visible_value_p)->len + 1;

   173

                }

   174

                char* next_cursor = buffer_cursor + size;

   175

                /* copy data to the buffer */

   176

                memcpy(buffer_cursor, visible_value_p, size);

   177

                /* increment cursor according size*/

   178

                buffer_cursor = next_cursor;

   179

            }

   180

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

   181

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

   182

                memcpy(real_value_p, visible_value_p, size);

   183

            }

   184

        }

   185

        if(flags & __IEC_RETAIN_FLAG){

   186

            /* compute next cursor positon*/

   187

            unsigned int next_retain_offset = retain_offset + size;

   188

            /* if buffer not full */

   189

            Retain(retain_offset, size, real_value_p);

   190

            /* increment cursor according size*/

   191

            retain_offset = next_retain_offset;

   192

        }

   193

    }

   194

}

   195

   196

void DebugIterator(dbgvardsc_t *dsc){

   197

    BufferIterator(dsc, 1);

   198

}

   199

   200

void RetainIterator(dbgvardsc_t *dsc){

   201

    BufferIterator(dsc, 0);

   202

}

   203

   204

extern void PLC_GetTime(IEC_TIME*);

   205

extern int TryEnterDebugSection(void);

   206

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

   207

extern long long AtomicCompareExchange64(long long* , long long , long long);

   208

extern void LeaveDebugSection(void);

   209

extern void ValidateRetainBuffer(void);

   210

extern void InValidateRetainBuffer(void);

   211

   212

void __publish_debug(void)

   213

{

   214

    retain_offset = 0;

   215

    InValidateRetainBuffer();

   216

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

   217

    if(TryEnterDebugSection()){

   218

        /* Lock buffer */

   219

        long latest_state = AtomicCompareExchange(

   220

            &buffer_state,

   221

            BUFFER_FREE,

   222

            BUFFER_BUSY);

   223

   224

        /* If buffer was free */

   225

        if(latest_state == BUFFER_FREE)

   226

        {

   227

            /* Reset buffer cursor */

   228

            buffer_cursor = debug_buffer;

   229

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

   230

            __for_each_variable_do(DebugIterator);

   231

   232

            /* Leave debug section,

   233

             * Trigger asynchronous transmission 

   234

             * (returns immediately) */

   235

            InitiateDebugTransfer(); /* size */

   236

        }else{

   237

            /* when not debugging, do only retain */

   238

            __for_each_variable_do(RetainIterator);

   239

        }

   240

        LeaveDebugSection();

   241

    }else{

   242

        /* when not debugging, do only retain */

   243

        __for_each_variable_do(RetainIterator);

   244

    }

   245

    ValidateRetainBuffer();

   246

}

   247

   248

#define __RegisterDebugVariable_case_t(TYPENAME) \

   249

        case TYPENAME##_ENUM :\

   250

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

   251

            if(force)\

   252

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

   253

            break;

   254

#define __RegisterDebugVariable_case_p(TYPENAME)\

   255

        case TYPENAME##_P_ENUM :\

   256

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

   257

            if(force)\

   258

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

   259

            break;\

   260

        case TYPENAME##_O_ENUM :\

   261

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

   262

            if(force){\

   263

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

   264

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

   265

            }\

   266

            break;

   267

void RegisterDebugVariable(int idx, void* force)

   268

{

   269

    if(idx  < sizeof(dbgvardsc)/sizeof(dbgvardsc_t)){

   270

        unsigned char flags = force ?

   271

            __IEC_DEBUG_FLAG | __IEC_FORCE_FLAG :

   272

            __IEC_DEBUG_FLAG;

   273

        dbgvardsc_t *dsc = &dbgvardsc[idx];

   274

        void *varp = dsc->ptr;

   275

        switch(dsc->type){

   276

            __ANY(__RegisterDebugVariable_case_t)

   277

            __ANY(__RegisterDebugVariable_case_p)

   278

        default:

   279

            break;

   280

        }

   281

    }

   282

}

   283

   284

#define __ResetDebugVariablesIterator_case_t(TYPENAME) \

   285

        case TYPENAME##_ENUM :\

   286

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

   287

            break;

   288

   289

#define __ResetDebugVariablesIterator_case_p(TYPENAME)\

   290

        case TYPENAME##_P_ENUM :\

   291

        case TYPENAME##_O_ENUM :\

   292

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

   293

            break;

   294

   295

void ResetDebugVariablesIterator(dbgvardsc_t *dsc)

   296

{

   297

    /* force debug flag to 0*/

   298

    void *varp = dsc->ptr;

   299

    switch(dsc->type){

   300

        __ANY(__ResetDebugVariablesIterator_case_t)

   301

        __ANY(__ResetDebugVariablesIterator_case_p)

   302

    default:

   303

        break;

   304

    }

   305

}

   306

   307

void ResetDebugVariables(void)

   308

{

   309

    __for_each_variable_do(ResetDebugVariablesIterator);

   310

}

   311

   312

void FreeDebugData(void)

   313

{

   314

    /* atomically mark buffer as free */

   315

    AtomicCompareExchange(

   316

        &buffer_state,

   317

        BUFFER_BUSY,

   318

        BUFFER_FREE);

   319

}

   320

int WaitDebugData(unsigned long *tick);

   321

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

   322

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

   323

    int wait_error = WaitDebugData(tick);

   324

    if(!wait_error){

   325

        *size = buffer_cursor - debug_buffer;

   326

        *buffer = debug_buffer;

   327

    }

   328

    return wait_error;

   329

}

   330