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

extern void PLC_GetTime(IEC_TIME*);

   215

extern int TryEnterDebugSection(void);

   216

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

   217

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

   218

extern void LeaveDebugSection(void);

   219

extern void ValidateRetainBuffer(void);

   220

extern void InValidateRetainBuffer(void);

   221

   222

void __publish_debug(void)

   223

{

   224

    retain_offset = 0;

   225

    InValidateRetainBuffer();

   226

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

   227

    if(TryEnterDebugSection()){

   228

        /* Lock buffer */

   229

        long latest_state = AtomicCompareExchange(

   230

            &buffer_state,

   231

            BUFFER_FREE,

   232

            BUFFER_BUSY);

   233

   234

        /* If buffer was free */

   235

        if(latest_state == BUFFER_FREE)

   236

        {

   237

            /* Reset buffer cursor */

   238

            buffer_cursor = debug_buffer;

   239

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

   240

            __for_each_variable_do(DebugIterator);

   241

   242

            /* Leave debug section,

   243

             * Trigger asynchronous transmission 

   244

             * (returns immediately) */

   245

            InitiateDebugTransfer(); /* size */

   246

        }else{

   247

            /* when not debugging, do only retain */

   248

            __for_each_variable_do(RetainIterator);

   249

        }

   250

        LeaveDebugSection();

   251

    }else{

   252

        /* when not debugging, do only retain */

   253

        __for_each_variable_do(RetainIterator);

   254

    }

   255

    ValidateRetainBuffer();

   256

}

   257

   258

#define __RegisterDebugVariable_case_t(TYPENAME) \

   259

        case TYPENAME##_ENUM :\

   260

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

   261

            if(force)\

   262

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

   263

            break;

   264

#define __RegisterDebugVariable_case_p(TYPENAME)\

   265

        case TYPENAME##_P_ENUM :\

   266

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

   267

            if(force)\

   268

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

   269

            break;\

   270

        case TYPENAME##_O_ENUM :\

   271

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

   272

            if(force){\

   273

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

   274

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

   275

            }\

   276

            break;

   277

void RegisterDebugVariable(int idx, void* force)

   278

{

   279

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

   280

        unsigned char flags = force ?

   281

            __IEC_DEBUG_FLAG | __IEC_FORCE_FLAG :

   282

            __IEC_DEBUG_FLAG;

   283

        dbgvardsc_t *dsc = &dbgvardsc[idx];

   284

        void *varp = dsc->ptr;

   285

        switch(dsc->type){

   286

            __ANY(__RegisterDebugVariable_case_t)

   287

            __ANY(__RegisterDebugVariable_case_p)

   288

        default:

   289

            break;

   290

        }

   291

    }

   292

}

   293

   294

#define __ResetDebugVariablesIterator_case_t(TYPENAME) \

   295

        case TYPENAME##_ENUM :\

   296

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

   297

            break;

   298

   299

#define __ResetDebugVariablesIterator_case_p(TYPENAME)\

   300

        case TYPENAME##_P_ENUM :\

   301

        case TYPENAME##_O_ENUM :\

   302

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

   303

            break;

   304

   305

void ResetDebugVariablesIterator(dbgvardsc_t *dsc)

   306

{

   307

    /* force debug flag to 0*/

   308

    void *varp = dsc->ptr;

   309

    switch(dsc->type){

   310

        __ANY(__ResetDebugVariablesIterator_case_t)

   311

        __ANY(__ResetDebugVariablesIterator_case_p)

   312

    default:

   313

        break;

   314

    }

   315

}

   316

   317

void ResetDebugVariables(void)

   318

{

   319

    __for_each_variable_do(ResetDebugVariablesIterator);

   320

}

   321

   322

void FreeDebugData(void)

   323

{

   324

    /* atomically mark buffer as free */

   325

    AtomicCompareExchange(

   326

        &buffer_state,

   327

        BUFFER_BUSY,

   328

        BUFFER_FREE);

   329

}

   330

int WaitDebugData(unsigned long *tick);

   331

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

   332

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

   333

    int wait_error = WaitDebugData(tick);

   334

    if(!wait_error){

   335

        *size = buffer_cursor - debug_buffer;

   336

        *buffer = debug_buffer;

   337

    }

   338

    return wait_error;

   339

}

   340

   341

#endif

   342