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 __BufferDebugDataIterator_case_t(TYPENAME) \

    59

        case TYPENAME##_ENUM :\

    60

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

    61

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

    62

            break;

    63

    64

#define __BufferDebugDataIterator_case_p(TYPENAME)\

    65

        case TYPENAME##_P_ENUM :\

    66

        case TYPENAME##_O_ENUM :\

    67

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

    68

            if (*flags & __IEC_FORCE_FLAG)\

    69

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

    70

            else\

    71

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

    72

            break;

    73

    74

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

    75

{

    76

    /* find data to copy*/

    77

    switch(vartype){

    78

        ANY(__BufferDebugDataIterator_case_t)

    79

        ANY(__BufferDebugDataIterator_case_p)

    80

    default:

    81

        break;

    82

    }

    83

}

    84

    85

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

    86

    87

void RemindIterator(void* varp, __IEC_types_enum vartype)

    88

{

    89

    void *ptrvalue = NULL;

    90

    char flags = 0;

    91

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

    92

    93

    if(flags & __IEC_RETAIN_FLAG){

    94

        USINT size = __get_type_enum_size(vartype);

    95

        /* compute next cursor positon*/

    96

        unsigned int next_retain_offset = retain_offset + size;

    97

        /* if buffer not full */

    98

        Remind(retain_offset, size, ptrvalue);

    99

        /* increment cursor according size*/

   100

        retain_offset = next_retain_offset;

   101

    }

   102

}

   103

   105

   106

void __init_debug(void)

   107

{

   108

    /* init local static vars */

   109

    buffer_cursor = debug_buffer;

   110

    retain_offset = 0;

   111

    buffer_state = BUFFER_FREE;

   112

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

   113

    if(CheckRetainBuffer())

   114

    	__for_each_variable_do(RemindIterator);

   115

    retain_offset = 0;

   116

}

   117

   118

extern void InitiateDebugTransfer(void);

   119

   120

extern unsigned long __tick;

   121

   122

void __cleanup_debug(void)

   123

{

   124

    buffer_cursor = debug_buffer;

   125

    InitiateDebugTransfer();

   126

}

   127

   128

void __retrieve_debug(void)

   129

{

   130

}

   131

   132

void DoDebug(void *ptrvalue, char flags, USINT size)

   133

{

   134

    /* compute next cursor positon*/

   135

    char* next_cursor = buffer_cursor + size;

   136

    /* if buffer not full */

   137

    if(next_cursor <= debug_buffer + BUFFER_SIZE)

   138

    {

   139

        /* copy data to the buffer */

   140

        memcpy(buffer_cursor, ptrvalue, size);

   141

        /* increment cursor according size*/

   142

        buffer_cursor = next_cursor;

   143

    }else{

   144

        /*TODO : signal overflow*/

   145

    }

   146

}

   147

   148

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

   149

void DoRetain(void *ptrvalue, char flags, USINT size){

   150

    /* compute next cursor positon*/

   151

    unsigned int next_retain_offset = retain_offset + size;

   152

    /* if buffer not full */

   153

    Retain(retain_offset, size, ptrvalue);

   154

    /* increment cursor according size*/

   155

    retain_offset = next_retain_offset;

   156

}

   157

   158

void BufferDebugDataIterator(void* varp, __IEC_types_enum vartype)

   159

{

   160

    void *ptrvalue = NULL;

   161

    char flags = 0;

   162

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

   163

    /* For optimization purpose we do retain and debug in the same pass */

   164

    if(flags & (__IEC_DEBUG_FLAG | __IEC_RETAIN_FLAG)){

   165

        USINT size = __get_type_enum_size(vartype);

   166

        if(flags & __IEC_DEBUG_FLAG){

   167

            DoDebug(ptrvalue, flags, size);

   168

        }

   169

        if(flags & __IEC_RETAIN_FLAG){

   170

            DoRetain(ptrvalue, flags, size);

   171

        }

   172

    }

   173

}

   174

   175

void RetainIterator(void* varp, __IEC_types_enum vartype)

   176

{

   177

    void *ptrvalue = NULL;

   178

    char flags = 0;

   179

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

   180

   181

    if(flags & __IEC_RETAIN_FLAG){

   182

        USINT size = __get_type_enum_size(vartype);

   183

        DoRetain(ptrvalue, flags, size);

   184

    }

   185

}

   186

   187

extern int TryEnterDebugSection(void);

   188

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

   189

extern void LeaveDebugSection(void);

   192

   193

void __publish_debug(void)

   194

{

   195

    retain_offset = 0;

   197

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

   198

    if(TryEnterDebugSection()){

   199

        /* Lock buffer */

   200

        long latest_state = AtomicCompareExchange(

   201

            &buffer_state,

   202

            BUFFER_FREE,

   203

            BUFFER_BUSY);

   204

   205

        /* If buffer was free */

   206

        if(latest_state == BUFFER_FREE)

   207

        {

   208

            /* Reset buffer cursor */

   209

            buffer_cursor = debug_buffer;

   210

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

   211

            __for_each_variable_do(BufferDebugDataIterator);

   212

   213

            /* Leave debug section,

   214

             * Trigger asynchronous transmission 

   215

             * (returns immediately) */

   216

            InitiateDebugTransfer(); /* size */

   217

        }

   218

        LeaveDebugSection();

   219

    }else{

   220

        /* when not debugging, do only retain */

   221

        __for_each_variable_do(RetainIterator);

   222

    }

   224

}

   225

   226

#define __RegisterDebugVariable_case_t(TYPENAME) \

   227

        case TYPENAME##_ENUM :\

   228

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

   229

            if(force)\

   230

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

   231

            break;

   232

#define __RegisterDebugVariable_case_p(TYPENAME)\

   233

        case TYPENAME##_P_ENUM :\

   234

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

   235

            if(force)\

   236

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

   237

            break;\

   238

        case TYPENAME##_O_ENUM :\

   239

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

   240

            if(force)\

   241

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

   242

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

   243

            break;

   244

void RegisterDebugVariable(int idx, void* force)

   245

{

   246

    void *varp = NULL;

   247

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

   248

    switch(__find_variable(idx, &varp)){

   249

        ANY(__RegisterDebugVariable_case_t)

   250

        ANY(__RegisterDebugVariable_case_p)

   251

    default:

   252

        break;

   253

    }

   254

}

   255

   256

#define __ResetDebugVariablesIterator_case_t(TYPENAME) \

   257

        case TYPENAME##_ENUM :\

   258

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

   259

            break;

   260

   261

#define __ResetDebugVariablesIterator_case_p(TYPENAME)\

   262

        case TYPENAME##_P_ENUM :\

   263

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

   264

            break;

   265

   266

void ResetDebugVariablesIterator(void* varp, __IEC_types_enum vartype)

   267

{

   268

    /* force debug flag to 0*/

   269

    switch(vartype){

   270

        ANY(__ResetDebugVariablesIterator_case_t)

   271

        ANY(__ResetDebugVariablesIterator_case_p)

   272

    default:

   273

        break;

   274

    }

   275

}

   276

   277

void ResetDebugVariables(void)

   278

{

   279

    __for_each_variable_do(ResetDebugVariablesIterator);

   280

}

   281

   282

void FreeDebugData(void)

   283

{

   284

    /* atomically mark buffer as free */

   285

    long latest_state;

   286

    latest_state = AtomicCompareExchange(

   287

        &buffer_state,

   288

        BUFFER_BUSY,

   289

        BUFFER_FREE);

   290

}

   291

int WaitDebugData(unsigned long *tick);

   292

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

   293

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

   294

    int wait_error = WaitDebugData(tick);

   295

    if(!wait_error){

   296

        *size = buffer_cursor - debug_buffer;

   297

        *buffer = debug_buffer;

   298

    }

   299

    return wait_error;

   300

}

   301