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

#ifdef TARGET_DEBUG_AND_RETAIN_DISABLE

    14

    15

void __init_debug    (void){}

    16

void __cleanup_debug (void){}

    17

void __retrieve_debug(void){}

    18

void __publish_debug (void){}

    19

    20

#else

    21

    22

#include "iec_types_all.h"

    23

#include "POUS.h"

    24

/*for memcpy*/

    25

#include <string.h>

    26

#include <stdio.h>

    27

    28

#ifndef TARGET_ONLINE_DEBUG_DISABLE

    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

#endif

    42

    43

static unsigned int retain_offset = 0;

    44

/***

    45

 * Declare programs 

    46

 **/

    47

%(programs_declarations)s

    48

    49

/***

    50

 * Declare global variables from resources and conf 

    51

 **/

    52

%(extern_variables_declarations)s

    53

    54

typedef const struct {

    55

    void *ptr;

    56

    __IEC_types_enum type;

    57

} dbgvardsc_t;

    58

    59

static dbgvardsc_t dbgvardsc[] = {

    60

%(variable_decl_array)s

    61

};

    62

    63

typedef void(*__for_each_variable_do_fp)(dbgvardsc_t*);

    64

void __for_each_variable_do(__for_each_variable_do_fp fp)

    65

{

    66

    unsigned int i;

    67

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

    68

        dbgvardsc_t *dsc = &dbgvardsc[i];

    69

        if(dsc->type != UNKNOWN_ENUM) 

    70

            (*fp)(dsc);

    71

    }

    72

}

    73

    74

#define __Unpack_case_t(TYPENAME) \

    75

        case TYPENAME##_ENUM :\

    76

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

    77

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

    78

            break;

    79

    80

#define __Unpack_case_p(TYPENAME)\

    81

        case TYPENAME##_O_ENUM :\

    82

            *flags = __IEC_OUTPUT_FLAG;\

    83

        case TYPENAME##_P_ENUM :\

    84

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

    85

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

    86

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

    87

            break;

    88

    89

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

    90

{

    91

    void *varp = dsc->ptr;

    92

    void *forced_value_p = NULL;

    93

    *flags = 0;

    94

    /* find data to copy*/

    95

    switch(dsc->type){

    96

        __ANY(__Unpack_case_t)

    97

        __ANY(__Unpack_case_p)

    98

    default:

    99

        break;

   100

    }

   101

    if (*flags & __IEC_FORCE_FLAG)

   102

        return forced_value_p;

   103

    return *real_value_p;

   104

}

   105

   106

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

   107

   108

void RemindIterator(dbgvardsc_t *dsc)

   109

{

   110

    void *real_value_p = NULL;

   111

    char flags = 0;

   112

    UnpackVar(dsc, &real_value_p, &flags);

   113

   114

    if(flags & __IEC_RETAIN_FLAG){

   115

        USINT size = __get_type_enum_size(dsc->type);

   116

        /* compute next cursor positon*/

   117

        unsigned int next_retain_offset = retain_offset + size;

   118

        /* if buffer not full */

   119

        Remind(retain_offset, size, real_value_p);

   120

        /* increment cursor according size*/

   121

        retain_offset = next_retain_offset;

   122

    }

   123

}

   124

   125

extern int CheckRetainBuffer(void);

   126

extern void InitRetain(void);

   127

   128

void __init_debug(void)

   129

{

   130

    /* init local static vars */

   131

#ifndef TARGET_ONLINE_DEBUG_DISABLE	

   132

    buffer_cursor = debug_buffer;

   133

    buffer_state = BUFFER_FREE;

   134

#endif

   135

   136

    retain_offset = 0;

   137

    InitRetain();

   138

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

   139

    if(CheckRetainBuffer()){

   140

    	__for_each_variable_do(RemindIterator);

   141

    }else{

   142

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

   143

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

   144

    }

   145

    retain_offset = 0;

   146

}

   147

   148

extern void InitiateDebugTransfer(void);

   149

extern void CleanupRetain(void);

   150

   151

extern unsigned long __tick;

   152

   153

void __cleanup_debug(void)

   154

{

   155

#ifndef TARGET_ONLINE_DEBUG_DISABLE	

   156

    buffer_cursor = debug_buffer;

   157

    InitiateDebugTransfer();

   158

#endif    

   159

   160

    CleanupRetain();

   161

}

   162

   163

void __retrieve_debug(void)

   164

{

   165

}

   166

   167

   168

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

   169

   170

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

   171

{

   172

    void *real_value_p = NULL;

   173

    void *visible_value_p = NULL;

   174

    char flags = 0;

   175

   176

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

   177

   178

    if(flags & ( __IEC_DEBUG_FLAG | __IEC_RETAIN_FLAG)){

   179

        USINT size = __get_type_enum_size(dsc->type);

   180

   181

#ifndef TARGET_ONLINE_DEBUG_DISABLE	

   182

        if(flags & __IEC_DEBUG_FLAG){

   183

            /* copy visible variable to buffer */;

   184

            if(do_debug){

   185

                /* compute next cursor positon.

   186

                   No need to check overflow, as BUFFER_SIZE

   187

                   is computed large enough */

   188

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

   189

		   (dsc->type == STRING_P_ENUM) ||

   190

		   (dsc->type == STRING_O_ENUM)){

   191

                    /* optimization for strings */

   192

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

   193

                }

   194

                char* next_cursor = buffer_cursor + size;

   195

                /* copy data to the buffer */

   196

                memcpy(buffer_cursor, visible_value_p, size);

   197

                /* increment cursor according size*/

   198

                buffer_cursor = next_cursor;

   199

            }

   200

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

   201

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

   202

                memcpy(real_value_p, visible_value_p, size);

   203

            }

   204

        }

   205

#endif	

   206

   207

        if(flags & __IEC_RETAIN_FLAG){

   208

            /* compute next cursor positon*/

   209

            unsigned int next_retain_offset = retain_offset + size;

   210

            /* if buffer not full */

   211

            Retain(retain_offset, size, real_value_p);

   212

            /* increment cursor according size*/

   213

            retain_offset = next_retain_offset;

   214

        }

   215

    }

   216

}

   217

   218

void DebugIterator(dbgvardsc_t *dsc){

   219

    BufferIterator(dsc, 1);

   220

}

   221

   222

void RetainIterator(dbgvardsc_t *dsc){

   223

    BufferIterator(dsc, 0);

   224

}

   225

   226

   227

unsigned int retain_size = 0;

   228

   229

/* GetRetainSizeIterator */

   230

void GetRetainSizeIterator(dbgvardsc_t *dsc)

   231

{

   232

    void *real_value_p = NULL;

   233

    char flags = 0;

   234

    UnpackVar(dsc, &real_value_p, &flags);

   235

   236

    if(flags & __IEC_RETAIN_FLAG){

   237

        USINT size = __get_type_enum_size(dsc->type);

   238

        /* Calc retain buffer size */

   239

        retain_size += size;

   240

    }

   241

}

   242

   243

/* Return size of all retain variables */

   244

unsigned int GetRetainSize(void)

   245

{

   246

    __for_each_variable_do(GetRetainSizeIterator);

   247

    return retain_size;

   248

}

   249

   250

   251

extern void PLC_GetTime(IEC_TIME*);

   252

extern int TryEnterDebugSection(void);

   253

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

   254

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

   255

extern void LeaveDebugSection(void);

   256

extern void ValidateRetainBuffer(void);

   257

extern void InValidateRetainBuffer(void);

   258

   259

void __publish_debug(void)

   260

{

   261

    retain_offset = 0;

   262

    InValidateRetainBuffer();

   263

   264

#ifndef TARGET_ONLINE_DEBUG_DISABLE 

   265

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

   266

    if(TryEnterDebugSection()){

   267

        /* Lock buffer */

   268

        long latest_state = AtomicCompareExchange(

   269

            &buffer_state,

   270

            BUFFER_FREE,

   271

            BUFFER_BUSY);

   272

   273

        /* If buffer was free */

   274

        if(latest_state == BUFFER_FREE)

   275

        {

   276

            /* Reset buffer cursor */

   277

            buffer_cursor = debug_buffer;

   278

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

   279

            __for_each_variable_do(DebugIterator);

   280

   281

            /* Leave debug section,

   282

             * Trigger asynchronous transmission 

   283

             * (returns immediately) */

   284

            InitiateDebugTransfer(); /* size */

   285

        }else{

   286

            /* when not debugging, do only retain */

   287

            __for_each_variable_do(RetainIterator);

   288

        }

   289

        LeaveDebugSection();

   290

    }else

   291

#endif

   292

    {

   293

        /* when not debugging, do only retain */

   294

        __for_each_variable_do(RetainIterator);

   295

    }

   296

    ValidateRetainBuffer();

   297

}

   298

   299

#ifndef TARGET_ONLINE_DEBUG_DISABLE

   300

#define __RegisterDebugVariable_case_t(TYPENAME) \

   301

        case TYPENAME##_ENUM :\

   302

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

   303

            if(force)\

   304

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

   305

            break;

   306

#define __RegisterDebugVariable_case_p(TYPENAME)\

   307

        case TYPENAME##_P_ENUM :\

   308

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

   309

            if(force)\

   310

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

   311

            break;\

   312

        case TYPENAME##_O_ENUM :\

   313

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

   314

            if(force){\

   315

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

   316

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

   317

            }\

   318

            break;

   319

void RegisterDebugVariable(unsigned int idx, void* force)

   320

{

   321

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

   322

        unsigned char flags = force ?

   323

            __IEC_DEBUG_FLAG | __IEC_FORCE_FLAG :

   324

            __IEC_DEBUG_FLAG;

   325

        dbgvardsc_t *dsc = &dbgvardsc[idx];

   326

        void *varp = dsc->ptr;

   327

        switch(dsc->type){

   328

            __ANY(__RegisterDebugVariable_case_t)

   329

            __ANY(__RegisterDebugVariable_case_p)

   330

        default:

   331

            break;

   332

        }

   333

    }

   334

}

   335

   336

#define __ResetDebugVariablesIterator_case_t(TYPENAME) \

   337

        case TYPENAME##_ENUM :\

   338

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

   339

            break;

   340

   341

#define __ResetDebugVariablesIterator_case_p(TYPENAME)\

   342

        case TYPENAME##_P_ENUM :\

   343

        case TYPENAME##_O_ENUM :\

   344

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

   345

            break;

   346

   347

void ResetDebugVariablesIterator(dbgvardsc_t *dsc)

   348

{

   349

    /* force debug flag to 0*/

   350

    void *varp = dsc->ptr;

   351

    switch(dsc->type){

   352

        __ANY(__ResetDebugVariablesIterator_case_t)

   353

        __ANY(__ResetDebugVariablesIterator_case_p)

   354

    default:

   355

        break;

   356

    }

   357

}

   358

   359

void ResetDebugVariables(void)

   360

{

   361

    __for_each_variable_do(ResetDebugVariablesIterator);

   362

}

   363

   364

void FreeDebugData(void)

   365

{

   366

    /* atomically mark buffer as free */

   367

    AtomicCompareExchange(

   368

        &buffer_state,

   369

        BUFFER_BUSY,

   370

        BUFFER_FREE);

   371

}

   372

int WaitDebugData(unsigned long *tick);

   373

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

   374

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

   375

    int wait_error = WaitDebugData(tick);

   376

    if(!wait_error){

   377

        *size = buffer_cursor - debug_buffer;

   378

        *buffer = debug_buffer;

   379

    }

   380

    return wait_error;

   381

}

   382

#endif

   383

#endif

   384