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_desc_type dbgvardsc_t

    75

    76

%(var_access_code)s

    77

    78

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

    79

    80

void RemindIterator(dbgvardsc_t *dsc)

    81

{

    82

    void *real_value_p = NULL;

    83

    char flags = 0;

    84

    UnpackVar(dsc, &real_value_p, &flags);

    85

    86

    if(flags & __IEC_RETAIN_FLAG){

    87

        USINT size = __get_type_enum_size(dsc->type);

    88

        /* compute next cursor positon*/

    89

        unsigned int next_retain_offset = retain_offset + size;

    90

        /* if buffer not full */

    91

        Remind(retain_offset, size, real_value_p);

    92

        /* increment cursor according size*/

    93

        retain_offset = next_retain_offset;

    94

    }

    95

}

    96

    97

extern int CheckRetainBuffer(void);

    98

extern void InitRetain(void);

    99

   100

void __init_debug(void)

   101

{

   102

    /* init local static vars */

   103

#ifndef TARGET_ONLINE_DEBUG_DISABLE	

   104

    buffer_cursor = debug_buffer;

   105

    buffer_state = BUFFER_FREE;

   106

#endif

   107

   108

    retain_offset = 0;

   109

    InitRetain();

   110

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

   111

    if(CheckRetainBuffer()){

   112

    	__for_each_variable_do(RemindIterator);

   113

    }else{

   114

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

   115

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

   116

    }

   117

    retain_offset = 0;

   118

}

   119

   120

extern void InitiateDebugTransfer(void);

   121

extern void CleanupRetain(void);

   122

   123

extern unsigned long __tick;

   124

   125

void __cleanup_debug(void)

   126

{

   127

#ifndef TARGET_ONLINE_DEBUG_DISABLE	

   128

    buffer_cursor = debug_buffer;

   129

    InitiateDebugTransfer();

   130

#endif    

   131

   132

    CleanupRetain();

   133

}

   134

   135

void __retrieve_debug(void)

   136

{

   137

}

   138

   139

   140

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

   141

   142

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

   143

{

   144

    void *real_value_p = NULL;

   145

    void *visible_value_p = NULL;

   146

    char flags = 0;

   147

   148

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

   149

   150

    if(flags & ( __IEC_DEBUG_FLAG | __IEC_RETAIN_FLAG)){

   151

        USINT size = __get_type_enum_size(dsc->type);

   152

   153

#ifndef TARGET_ONLINE_DEBUG_DISABLE	

   154

        if(flags & __IEC_DEBUG_FLAG){

   155

            /* copy visible variable to buffer */;

   156

            if(do_debug){

   157

                /* compute next cursor positon.

   158

                   No need to check overflow, as BUFFER_SIZE

   159

                   is computed large enough */

   160

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

   161

		   (dsc->type == STRING_P_ENUM) ||

   162

		   (dsc->type == STRING_O_ENUM)){

   163

                    /* optimization for strings */

   164

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

   165

                }

   166

                char* next_cursor = buffer_cursor + size;

   167

                /* copy data to the buffer */

   168

                memcpy(buffer_cursor, visible_value_p, size);

   169

                /* increment cursor according size*/

   170

                buffer_cursor = next_cursor;

   171

            }

   172

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

   173

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

   174

                memcpy(real_value_p, visible_value_p, size);

   175

            }

   176

        }

   177

#endif	

   178

   179

        if(flags & __IEC_RETAIN_FLAG){

   180

            /* compute next cursor positon*/

   181

            unsigned int next_retain_offset = retain_offset + size;

   182

            /* if buffer not full */

   183

            Retain(retain_offset, size, real_value_p);

   184

            /* increment cursor according size*/

   185

            retain_offset = next_retain_offset;

   186

        }

   187

    }

   188

}

   189

   190

void DebugIterator(dbgvardsc_t *dsc){

   191

    BufferIterator(dsc, 1);

   192

}

   193

   194

void RetainIterator(dbgvardsc_t *dsc){

   195

    BufferIterator(dsc, 0);

   196

}

   197

   198

   199

unsigned int retain_size = 0;

   200

   201

/* GetRetainSizeIterator */

   202

void GetRetainSizeIterator(dbgvardsc_t *dsc)

   203

{

   204

    void *real_value_p = NULL;

   205

    char flags = 0;

   206

    UnpackVar(dsc, &real_value_p, &flags);

   207

   208

    if(flags & __IEC_RETAIN_FLAG){

   209

        USINT size = __get_type_enum_size(dsc->type);

   210

        /* Calc retain buffer size */

   211

        retain_size += size;

   212

    }

   213

}

   214

   215

/* Return size of all retain variables */

   216

unsigned int GetRetainSize(void)

   217

{

   218

    __for_each_variable_do(GetRetainSizeIterator);

   219

    return retain_size;

   220

}

   221

   222

   223

extern void PLC_GetTime(IEC_TIME*);

   224

extern int TryEnterDebugSection(void);

   225

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

   226

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

   227

extern void LeaveDebugSection(void);

   228

extern void ValidateRetainBuffer(void);

   229

extern void InValidateRetainBuffer(void);

   230

   231

void __publish_debug(void)

   232

{

   233

    retain_offset = 0;

   234

    InValidateRetainBuffer();

   235

   236

#ifndef TARGET_ONLINE_DEBUG_DISABLE 

   237

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

   238

    if(TryEnterDebugSection()){

   239

        /* Lock buffer */

   240

        long latest_state = AtomicCompareExchange(

   241

            &buffer_state,

   242

            BUFFER_FREE,

   243

            BUFFER_BUSY);

   244

   245

        /* If buffer was free */

   246

        if(latest_state == BUFFER_FREE)

   247

        {

   248

            /* Reset buffer cursor */

   249

            buffer_cursor = debug_buffer;

   250

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

   251

            __for_each_variable_do(DebugIterator);

   252

   253

            /* Leave debug section,

   254

             * Trigger asynchronous transmission 

   255

             * (returns immediately) */

   256

            InitiateDebugTransfer(); /* size */

   257

        }else{

   258

            /* when not debugging, do only retain */

   259

            __for_each_variable_do(RetainIterator);

   260

        }

   261

        LeaveDebugSection();

   262

    }else

   263

#endif

   264

    {

   265

        /* when not debugging, do only retain */

   266

        __for_each_variable_do(RetainIterator);

   267

    }

   268

    ValidateRetainBuffer();

   269

}

   270

   271

#ifndef TARGET_ONLINE_DEBUG_DISABLE

   272

#define __RegisterDebugVariable_case_t(TYPENAME) \

   273

        case TYPENAME##_ENUM :\

   274

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

   275

            if(force)\

   276

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

   277

            break;

   278

#define __RegisterDebugVariable_case_p(TYPENAME)\

   279

        case TYPENAME##_P_ENUM :\

   280

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

   281

            if(force)\

   282

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

   283

            break;\

   284

        case TYPENAME##_O_ENUM :\

   285

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

   286

            if(force){\

   287

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

   288

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

   289

            }\

   290

            break;

   291

void RegisterDebugVariable(unsigned int idx, void* force)

   292

{

   293

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

   294

        unsigned char flags = force ?

   295

            __IEC_DEBUG_FLAG | __IEC_FORCE_FLAG :

   296

            __IEC_DEBUG_FLAG;

   297

        dbgvardsc_t *dsc = &dbgvardsc[idx];

   298

        void *varp = dsc->ptr;

   299

        switch(dsc->type){

   300

            __ANY(__RegisterDebugVariable_case_t)

   301

            __ANY(__RegisterDebugVariable_case_p)

   302

        default:

   303

            break;

   304

        }

   305

    }

   306

}

   307

   308

#define __ResetDebugVariablesIterator_case_t(TYPENAME) \

   309

        case TYPENAME##_ENUM :\

   310

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

   311

            break;

   312

   313

#define __ResetDebugVariablesIterator_case_p(TYPENAME)\

   314

        case TYPENAME##_P_ENUM :\

   315

        case TYPENAME##_O_ENUM :\

   316

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

   317

            break;

   318

   319

void ResetDebugVariablesIterator(dbgvardsc_t *dsc)

   320

{

   321

    /* force debug flag to 0*/

   322

    void *varp = dsc->ptr;

   323

    switch(dsc->type){

   324

        __ANY(__ResetDebugVariablesIterator_case_t)

   325

        __ANY(__ResetDebugVariablesIterator_case_p)

   326

    default:

   327

        break;

   328

    }

   329

}

   330

   331

void ResetDebugVariables(void)

   332

{

   333

    __for_each_variable_do(ResetDebugVariablesIterator);

   334

}

   335

   336

void FreeDebugData(void)

   337

{

   338

    /* atomically mark buffer as free */

   339

    AtomicCompareExchange(

   340

        &buffer_state,

   341

        BUFFER_BUSY,

   342

        BUFFER_FREE);

   343

}

   344

int WaitDebugData(unsigned long *tick);

   345

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

   346

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

   347

    int wait_error = WaitDebugData(tick);

   348

    if(!wait_error){

   349

        *size = buffer_cursor - debug_buffer;

   350

        *buffer = debug_buffer;

   351

    }

   352

    return wait_error;

   353

}

   354

#endif

   355

#endif

   356