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

    14

#ifdef TARGET_DEBUG_DISABLE

    15

    16

void __init_debug    (void){}

    17

void __cleanup_debug (void){}

    18

void __retrieve_debug(void){}

    19

void __publish_debug (void){}

    20

    21

#else

    22

    23

#include "iec_types_all.h"

    24

#include "POUS.h"

    25

/*for memcpy*/

    26

#include <string.h>

    27

#include <stdio.h>

    28

    29

#define BUFFER_SIZE %(buffer_size)d

    30

    31

/* Atomically accessed variable for buffer state */

    32

#define BUFFER_FREE 0

    33

#define BUFFER_BUSY 1

    34

static long buffer_state = BUFFER_FREE;

    35

    36

/* The buffer itself */

    37

char debug_buffer[BUFFER_SIZE];

    38

    39

/* Buffer's cursor*/

    40

static char* buffer_cursor = debug_buffer;

    41

static unsigned int retain_offset = 0;

    42

/***

    43

 * Declare programs 

    44

 **/

    45

%(programs_declarations)s

    46

    47

/***

    48

 * Declare global variables from resources and conf 

    49

 **/

    50

%(extern_variables_declarations)s

    51

    52

typedef const struct {

    53

    void *ptr;

    54

    __IEC_types_enum type;

    55

} dbgvardsc_t;

    56

    57

static dbgvardsc_t dbgvardsc[] = {

    58

%(variable_decl_array)s

    59

};

    60

    61

typedef void(*__for_each_variable_do_fp)(dbgvardsc_t*);

    62

void __for_each_variable_do(__for_each_variable_do_fp fp)

    63

{

    64

    int i;

    65

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

    66

        dbgvardsc_t *dsc = &dbgvardsc[i];

    67

        if(dsc->type != UNKNOWN_ENUM) 

    68

            (*fp)(dsc);

    69

    }

    70

}

    71

    72

#define __Unpack_case_t(TYPENAME) \

    73

        case TYPENAME##_ENUM :\

    74

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

    75

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

    76

            break;

    77

    78

#define __Unpack_case_p(TYPENAME)\

    79

        case TYPENAME##_O_ENUM :\

    80

            *flags = __IEC_OUTPUT_FLAG;\

    81

        case TYPENAME##_P_ENUM :\

    82

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

    83

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

    84

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

    85

            break;

    86

    87

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

    88

{

    89

    void *varp = dsc->ptr;

    90

    void *forced_value_p = NULL;

    91

    *flags = 0;

    92

    /* find data to copy*/

    93

    switch(dsc->type){

    94

        __ANY(__Unpack_case_t)

    95

        __ANY(__Unpack_case_p)

    96

    default:

    97

        break;

    98

    }

    99

    if (*flags & __IEC_FORCE_FLAG)

   100

        return forced_value_p;

   101

    return *real_value_p;

   102

}

   103

   104

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

   105

   106

void RemindIterator(dbgvardsc_t *dsc)

   107

{

   108

    void *real_value_p = NULL;

   109

    char flags = 0;

   110

    UnpackVar(dsc, &real_value_p, &flags);

   111

   112

    if(flags & __IEC_RETAIN_FLAG){

   113

        USINT size = __get_type_enum_size(dsc->type);

   114

        /* compute next cursor positon*/

   115

        unsigned int next_retain_offset = retain_offset + size;

   116

        /* if buffer not full */

   117

        Remind(retain_offset, size, real_value_p);

   118

        /* increment cursor according size*/

   119

        retain_offset = next_retain_offset;

   120

    }

   121

}

   122

   123

extern int CheckRetainBuffer(void);

   124

extern void InitRetain(void);

   125

   126

void __init_debug(void)

   127

{

   128

    /* init local static vars */

   129

    buffer_cursor = debug_buffer;

   130

    retain_offset = 0;

   131

    buffer_state = BUFFER_FREE;

   132

    InitRetain();

   133

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

   134

    if(CheckRetainBuffer()){

   135

    	__for_each_variable_do(RemindIterator);

   136

    }else{

   137

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

   138

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

   139

    }

   140

    retain_offset = 0;

   141

}

   142

   143

extern void InitiateDebugTransfer(void);

   144

extern void CleanupRetain(void);

   145

   146

extern unsigned long __tick;

   147

   148

void __cleanup_debug(void)

   149

{

   150

    buffer_cursor = debug_buffer;

   151

    InitiateDebugTransfer();

   152

    CleanupRetain();

   153

}

   154

   155

void __retrieve_debug(void)

   156

{

   157

}

   158

   159

   160

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

   161

   162

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

   163

{

   164

    void *real_value_p = NULL;

   165

    void *visible_value_p = NULL;

   166

    char flags = 0;

   167

   168

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

   169

   170

    if(flags & ( __IEC_DEBUG_FLAG | __IEC_RETAIN_FLAG)){

   171

        USINT size = __get_type_enum_size(dsc->type);

   172

        if(flags & __IEC_DEBUG_FLAG){

   173

            /* copy visible variable to buffer */;

   174

            if(do_debug){

   175

                /* compute next cursor positon.

   176

                   No need to check overflow, as BUFFER_SIZE

   177

                   is computed large enough */

   178

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

   179

		   (dsc->type == STRING_P_ENUM) ||

   180

		   (dsc->type == STRING_O_ENUM)){

   181

                    /* optimization for strings */

   182

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

   183

                }

   184

                char* next_cursor = buffer_cursor + size;

   185

                /* copy data to the buffer */

   186

                memcpy(buffer_cursor, visible_value_p, size);

   187

                /* increment cursor according size*/

   188

                buffer_cursor = next_cursor;

   189

            }

   190

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

   191

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

   192

                memcpy(real_value_p, visible_value_p, size);

   193

            }

   194

        }

   195

        if(flags & __IEC_RETAIN_FLAG){

   196

            /* compute next cursor positon*/

   197

            unsigned int next_retain_offset = retain_offset + size;

   198

            /* if buffer not full */

   199

            Retain(retain_offset, size, real_value_p);

   200

            /* increment cursor according size*/

   201

            retain_offset = next_retain_offset;

   202

        }

   203

    }

   204

}

   205

   206

void DebugIterator(dbgvardsc_t *dsc){

   207

    BufferIterator(dsc, 1);

   208

}

   209

   210

void RetainIterator(dbgvardsc_t *dsc){

   211

    BufferIterator(dsc, 0);

   212

}

   213

   214

   215

unsigned int retain_size = 0;

   216

   217

/* GetRetainSizeIterator */

   218

void GetRetainSizeIterator(dbgvardsc_t *dsc)

   219

{

   220

    void *real_value_p = NULL;

   221

    char flags = 0;

   222

    UnpackVar(dsc, &real_value_p, &flags);

   223

   224

    if(flags & __IEC_RETAIN_FLAG){

   225

        USINT size = __get_type_enum_size(dsc->type);

   226

        /* Calc retain buffer size */

   227

        retain_size += size;

   228

    }

   229

}

   230

   231

/* Return size of all retain variables */

   232

unsigned int GetRetainSize(void)

   233

{

   234

    __for_each_variable_do(GetRetainSizeIterator);

   235

    return retain_size;

   236

}

   237

   238

   239

extern void PLC_GetTime(IEC_TIME*);

   240

extern int TryEnterDebugSection(void);

   241

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

   242

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

   243

extern void LeaveDebugSection(void);

   244

extern void ValidateRetainBuffer(void);

   245

extern void InValidateRetainBuffer(void);

   246

   247

void __publish_debug(void)

   248

{

   249

    retain_offset = 0;

   250

    InValidateRetainBuffer();

   251

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

   252

    if(TryEnterDebugSection()){

   253

        /* Lock buffer */

   254

        long latest_state = AtomicCompareExchange(

   255

            &buffer_state,

   256

            BUFFER_FREE,

   257

            BUFFER_BUSY);

   258

   259

        /* If buffer was free */

   260

        if(latest_state == BUFFER_FREE)

   261

        {

   262

            /* Reset buffer cursor */

   263

            buffer_cursor = debug_buffer;

   264

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

   265

            __for_each_variable_do(DebugIterator);

   266

   267

            /* Leave debug section,

   268

             * Trigger asynchronous transmission 

   269

             * (returns immediately) */

   270

            InitiateDebugTransfer(); /* size */

   271

        }else{

   272

            /* when not debugging, do only retain */

   273

            __for_each_variable_do(RetainIterator);

   274

        }

   275

        LeaveDebugSection();

   276

    }else{

   277

        /* when not debugging, do only retain */

   278

        __for_each_variable_do(RetainIterator);

   279

    }

   280

    ValidateRetainBuffer();

   281

}

   282

   283

#define __RegisterDebugVariable_case_t(TYPENAME) \

   284

        case TYPENAME##_ENUM :\

   285

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

   286

            if(force)\

   287

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

   288

            break;

   289

#define __RegisterDebugVariable_case_p(TYPENAME)\

   290

        case TYPENAME##_P_ENUM :\

   291

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

   292

            if(force)\

   293

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

   294

            break;\

   295

        case TYPENAME##_O_ENUM :\

   296

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

   297

            if(force){\

   298

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

   299

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

   300

            }\

   301

            break;

   302

void RegisterDebugVariable(int idx, void* force)

   303

{

   304

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

   305

        unsigned char flags = force ?

   306

            __IEC_DEBUG_FLAG | __IEC_FORCE_FLAG :

   307

            __IEC_DEBUG_FLAG;

   308

        dbgvardsc_t *dsc = &dbgvardsc[idx];

   309

        void *varp = dsc->ptr;

   310

        switch(dsc->type){

   311

            __ANY(__RegisterDebugVariable_case_t)

   312

            __ANY(__RegisterDebugVariable_case_p)

   313

        default:

   314

            break;

   315

        }

   316

    }

   317

}

   318

   319

#define __ResetDebugVariablesIterator_case_t(TYPENAME) \

   320

        case TYPENAME##_ENUM :\

   321

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

   322

            break;

   323

   324

#define __ResetDebugVariablesIterator_case_p(TYPENAME)\

   325

        case TYPENAME##_P_ENUM :\

   326

        case TYPENAME##_O_ENUM :\

   327

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

   328

            break;

   329

   330

void ResetDebugVariablesIterator(dbgvardsc_t *dsc)

   331

{

   332

    /* force debug flag to 0*/

   333

    void *varp = dsc->ptr;

   334

    switch(dsc->type){

   335

        __ANY(__ResetDebugVariablesIterator_case_t)

   336

        __ANY(__ResetDebugVariablesIterator_case_p)

   337

    default:

   338

        break;

   339

    }

   340

}

   341

   342

void ResetDebugVariables(void)

   343

{

   344

    __for_each_variable_do(ResetDebugVariablesIterator);

   345

}

   346

   347

void FreeDebugData(void)

   348

{

   349

    /* atomically mark buffer as free */

   350

    AtomicCompareExchange(

   351

        &buffer_state,

   352

        BUFFER_BUSY,

   353

        BUFFER_FREE);

   354

}

   355

int WaitDebugData(unsigned long *tick);

   356

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

   357

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

   358

    int wait_error = WaitDebugData(tick);

   359

    if(!wait_error){

   360

        *size = buffer_cursor - debug_buffer;

   361

        *buffer = debug_buffer;

   362

    }

   363

    return wait_error;

   364

}

   365

   366

#endif

   367