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 void(*__for_each_variable_do_fp)(void*, __IEC_types_enum);

    43

void __for_each_variable_do(__for_each_variable_do_fp fp)

    44

{

    45

%(for_each_variable_do_code)s

    46

}

    47

    48

__IEC_types_enum __find_variable(unsigned int varindex, void ** varp)

    49

{

    50

    switch(varindex){

    51

%(find_variable_case_code)s

    52

     default:

    53

      *varp = NULL;

    54

      return UNKNOWN_ENUM;

    55

    }

    56

}

    57

    58

#define __Unpack_case_t(TYPENAME) \

    59

        case TYPENAME##_ENUM :\

    60

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

    61

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

    62

            break;

    63

    64

#define __Unpack_case_p(TYPENAME)\

    65

        case TYPENAME##_O_ENUM :\

    66

            *flags = __IEC_OUTPUT_FLAG;\

    67

        case TYPENAME##_P_ENUM :\

    68

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

    69

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

    70

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

    71

            break;

    72

    73

void* UnpackVar(void* varp, __IEC_types_enum vartype, void **real_value_p, char *flags)

    74

{

    75

    void *forced_value_p = NULL;

    76

    *flags = 0;

    77

    /* find data to copy*/

    78

    switch(vartype){

    79

        __ANY(__Unpack_case_t)

    80

        __ANY(__Unpack_case_p)

    81

    default:

    82

        break;

    83

    }

    84

    if (*flags & __IEC_FORCE_FLAG)

    85

        return forced_value_p;

    86

    return *real_value_p;

    87

}

    88

    89

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

    90

    91

void RemindIterator(void* varp, __IEC_types_enum vartype)

    92

{

    93

    void *real_value_p = NULL;

    94

    char flags = 0;

    95

    UnpackVar(varp, vartype, &real_value_p, &flags);

    96

    97

    if(flags & __IEC_RETAIN_FLAG){

    98

        USINT size = __get_type_enum_size(vartype);

    99

        /* compute next cursor positon*/

   100

        unsigned int next_retain_offset = retain_offset + size;

   101

        /* if buffer not full */

   102

        Remind(retain_offset, size, real_value_p);

   103

        /* increment cursor according size*/

   104

        retain_offset = next_retain_offset;

   105

    }

   106

}

   107

   108

extern int CheckRetainBuffer(void);

   109

   110

void __init_debug(void)

   111

{

   112

    /* init local static vars */

   113

    buffer_cursor = debug_buffer;

   114

    retain_offset = 0;

   115

    buffer_state = BUFFER_FREE;

   116

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

   117

    if(CheckRetainBuffer())

   118

    	__for_each_variable_do(RemindIterator);

   119

    retain_offset = 0;

   120

}

   121

   122

extern void InitiateDebugTransfer(void);

   123

   124

extern unsigned long __tick;

   125

   126

void __cleanup_debug(void)

   127

{

   128

    buffer_cursor = debug_buffer;

   129

    InitiateDebugTransfer();

   130

}

   131

   132

void __retrieve_debug(void)

   133

{

   134

}

   135

   136

   137

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

   138

   139

inline void BufferIterator(void* varp, __IEC_types_enum vartype, int do_debug)

   140

{

   141

    void *real_value_p = NULL;

   142

    void *visible_value_p = NULL;

   143

    char flags = 0;

   144

   145

    visible_value_p = UnpackVar(varp, vartype, &real_value_p, &flags);

   146

   147

    if(flags & ( __IEC_DEBUG_FLAG | __IEC_RETAIN_FLAG)){

   148

        USINT size = __get_type_enum_size(vartype);

   149

        if(flags & __IEC_DEBUG_FLAG){

   150

            /* copy visible variable to buffer */;

   151

            if(do_debug){

   152

                /* compute next cursor positon.

   153

                   No need to check overflow, as BUFFER_SIZE

   154

                   is computed large enough */

   155

                if(vartype == STRING_ENUM){

   156

                    /* optimization for strings */

   157

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

   158

                }

   159

                char* next_cursor = buffer_cursor + size;

   160

                /* copy data to the buffer */

   161

                memcpy(buffer_cursor, visible_value_p, size);

   162

                /* increment cursor according size*/

   163

                buffer_cursor = next_cursor;

   164

            }

   165

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

   166

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

   167

                memcpy(real_value_p, visible_value_p, size);

   168

            }

   169

        }

   170

        if(flags & __IEC_RETAIN_FLAG){

   171

            /* compute next cursor positon*/

   172

            unsigned int next_retain_offset = retain_offset + size;

   173

            /* if buffer not full */

   174

            Retain(retain_offset, size, real_value_p);

   175

            /* increment cursor according size*/

   176

            retain_offset = next_retain_offset;

   177

        }

   178

    }

   179

}

   180

   181

void DebugIterator(void* varp, __IEC_types_enum vartype){

   182

    BufferIterator(varp, vartype, 1);

   183

}

   184

   185

void RetainIterator(void* varp, __IEC_types_enum vartype){

   186

    BufferIterator(varp, vartype, 0);

   187

}

   188

   189

extern void PLC_GetTime(IEC_TIME*);

   190

extern int TryEnterDebugSection(void);

   191

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

   192

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

   193

extern void LeaveDebugSection(void);

   194

extern void ValidateRetainBuffer(void);

   195

extern void InValidateRetainBuffer(void);

   196

   197

void __publish_debug(void)

   198

{

   199

    retain_offset = 0;

   200

    InValidateRetainBuffer();

   201

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

   202

    if(TryEnterDebugSection()){

   203

        /* Lock buffer */

   204

        long latest_state = AtomicCompareExchange(

   205

            &buffer_state,

   206

            BUFFER_FREE,

   207

            BUFFER_BUSY);

   208

   209

        /* If buffer was free */

   210

        if(latest_state == BUFFER_FREE)

   211

        {

   212

            /* Reset buffer cursor */

   213

            buffer_cursor = debug_buffer;

   214

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

   215

            __for_each_variable_do(DebugIterator);

   216

   217

            /* Leave debug section,

   218

             * Trigger asynchronous transmission 

   219

             * (returns immediately) */

   220

            InitiateDebugTransfer(); /* size */

   221

        }else{

   222

            /* when not debugging, do only retain */

   223

            __for_each_variable_do(RetainIterator);

   224

        }

   225

        LeaveDebugSection();

   226

    }else{

   227

        /* when not debugging, do only retain */

   228

        __for_each_variable_do(RetainIterator);

   229

    }

   230

    ValidateRetainBuffer();

   231

}

   232

   233

#define __RegisterDebugVariable_case_t(TYPENAME) \

   234

        case TYPENAME##_ENUM :\

   235

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

   236

            if(force)\

   237

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

   238

            break;

   239

#define __RegisterDebugVariable_case_p(TYPENAME)\

   240

        case TYPENAME##_P_ENUM :\

   241

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

   242

            if(force)\

   243

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

   244

            break;\

   245

        case TYPENAME##_O_ENUM :\

   246

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

   247

            if(force){\

   248

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

   249

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

   250

            }\

   251

            break;

   252

void RegisterDebugVariable(int idx, void* force)

   253

{

   254

    void *varp = NULL;

   255

    unsigned char flags = force ? __IEC_DEBUG_FLAG | __IEC_FORCE_FLAG : __IEC_DEBUG_FLAG;

   256

    switch(__find_variable(idx, &varp)){

   257

        __ANY(__RegisterDebugVariable_case_t)

   258

        __ANY(__RegisterDebugVariable_case_p)

   259

    default:

   260

        break;

   261

    }

   262

}

   263

   264

#define __ResetDebugVariablesIterator_case_t(TYPENAME) \

   265

        case TYPENAME##_ENUM :\

   266

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

   267

            break;

   268

   269

#define __ResetDebugVariablesIterator_case_p(TYPENAME)\

   270

        case TYPENAME##_P_ENUM :\

   271

        case TYPENAME##_O_ENUM :\

   272

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

   273

            break;

   274

   275

void ResetDebugVariablesIterator(void* varp, __IEC_types_enum vartype)

   276

{

   277

    /* force debug flag to 0*/

   278

    switch(vartype){

   279

        __ANY(__ResetDebugVariablesIterator_case_t)

   280

        __ANY(__ResetDebugVariablesIterator_case_p)

   281

    default:

   282

        break;

   283

    }

   284

}

   285

   286

void ResetDebugVariables(void)

   287

{

   288

    __for_each_variable_do(ResetDebugVariablesIterator);

   289

}

   290

   291

void FreeDebugData(void)

   292

{

   293

    /* atomically mark buffer as free */

   294

    long latest_state;

   295

    latest_state = AtomicCompareExchange(

   296

        &buffer_state,

   297

        BUFFER_BUSY,

   298

        BUFFER_FREE);

   299

}

   300

int WaitDebugData(unsigned long *tick);

   301

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

   302

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

   303

    int wait_error = WaitDebugData(tick);

   304

    if(!wait_error){

   305

        *size = buffer_cursor - debug_buffer;

   306

        *buffer = debug_buffer;

   307

    }

   308

    return wait_error;

   309

}

   310