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

#define MAX_SUBSCRIBTION %(subscription_table_count)d

    21

    22

/* Atomically accessed variable for buffer state */

    23

#define BUFFER_FREE 0

    24

#define BUFFER_BUSY 1

    25

static long buffer_state = BUFFER_FREE;

    26

    27

/* The buffer itself */

    28

char debug_buffer[BUFFER_SIZE];

    29

    30

/* Buffer's cursor*/

    31

static char* buffer_cursor = debug_buffer;

    32

static unsigned int retain_offset = 0;

    33

/***

    34

 * Declare programs 

    35

 **/

    36

%(programs_declarations)s

    37

    38

/***

    39

 * Declare global variables from resources and conf 

    40

 **/

    41

%(extern_variables_declarations)s

    42

    43

typedef void(*__for_each_variable_do_fp)(void*, __IEC_types_enum);

    44

void __for_each_variable_do(__for_each_variable_do_fp fp)

    45

{

    46

%(for_each_variable_do_code)s

    47

}

    48

    49

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

    50

{

    51

    switch(varindex){

    52

%(find_variable_case_code)s

    53

     default:

    54

      *varp = NULL;

    55

      return UNKNOWN_ENUM;

    56

    }

    57

}

    58

    59

#define __BufferDebugDataIterator_case_t(TYPENAME) \

    60

        case TYPENAME##_ENUM :\

    61

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

    62

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

    63

            break;

    64

    65

#define __BufferDebugDataIterator_case_p(TYPENAME)\

    66

        case TYPENAME##_P_ENUM :\

    67

        case TYPENAME##_O_ENUM :\

    68

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

    69

            if (*flags & __IEC_FORCE_FLAG)\

    70

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

    71

            else\

    72

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

    73

            break;

    74

    75

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

    76

{

    77

    /* find data to copy*/

    78

    switch(vartype){

    79

        ANY(__BufferDebugDataIterator_case_t)

    80

        ANY(__BufferDebugDataIterator_case_p)

    81

    default:

    82

        break;

    83

    }

    84

}

    85

    86

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

    87

    88

void RemindIterator(void* varp, __IEC_types_enum vartype)

    89

{

    90

    void *ptrvalue = NULL;

    91

    char flags = 0;

    92

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

    93

    94

    if(flags & __IEC_RETAIN_FLAG){

    95

        USINT size = __get_type_enum_size(vartype);

    96

        /* compute next cursor positon*/

    97

        unsigned int next_retain_offset = retain_offset + size;

    98

        /* if buffer not full */

    99

        Remind(retain_offset, size, ptrvalue);

   100

        /* increment cursor according size*/

   101

        retain_offset = next_retain_offset;

   102

    }

   103

}

   104

   105

int CheckRetainBuffer(void);

   106

   107

void __init_debug(void)

   108

{

   109

    /* init local static vars */

   110

    buffer_cursor = debug_buffer;

   111

    retain_offset = 0;

   112

    buffer_state = BUFFER_FREE;

   113

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

   114

    if(CheckRetainBuffer())

   115

    	__for_each_variable_do(RemindIterator);

   116

    retain_offset = 0;

   117

}

   118

   119

extern void InitiateDebugTransfer(void);

   120

   121

extern unsigned long __tick;

   122

   123

void __cleanup_debug(void)

   124

{

   125

    buffer_cursor = debug_buffer;

   126

    InitiateDebugTransfer();

   127

}

   128

   129

void __retrieve_debug(void)

   130

{

   131

}

   132

   133

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

   134

{

   135

    /* compute next cursor positon*/

   136

    char* next_cursor = buffer_cursor + size;

   137

    /* if buffer not full */

   138

    if(next_cursor <= debug_buffer + BUFFER_SIZE)

   139

    {

   140

        /* copy data to the buffer */

   141

        memcpy(buffer_cursor, ptrvalue, size);

   142

        /* increment cursor according size*/

   143

        buffer_cursor = next_cursor;

   144

    }else{

   145

        /*TODO : signal overflow*/

   146

    }

   147

}

   148

   149

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

   150

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

   151

    /* compute next cursor positon*/

   152

    unsigned int next_retain_offset = retain_offset + size;

   153

    /* if buffer not full */

   154

    Retain(retain_offset, size, ptrvalue);

   155

    /* increment cursor according size*/

   156

    retain_offset = next_retain_offset;

   157

}

   158

   159

void BufferDebugDataIterator(void* varp, __IEC_types_enum vartype)

   160

{

   161

    void *ptrvalue = NULL;

   162

    char flags = 0;

   163

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

   164

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

   165

    if(flags & (__IEC_DEBUG_FLAG | __IEC_RETAIN_FLAG)){

   166

        USINT size = __get_type_enum_size(vartype);

   167

        if(flags & __IEC_DEBUG_FLAG){

   168

            DoDebug(ptrvalue, flags, size);

   169

        }

   170

        if(flags & __IEC_RETAIN_FLAG){

   171

            DoRetain(ptrvalue, flags, size);

   172

        }

   173

    }

   174

}

   175

   176

void RetainIterator(void* varp, __IEC_types_enum vartype)

   177

{

   178

    void *ptrvalue = NULL;

   179

    char flags = 0;

   180

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

   181

   182

    if(flags & __IEC_RETAIN_FLAG){

   183

        USINT size = __get_type_enum_size(vartype);

   184

        DoRetain(ptrvalue, flags, size);

   185

    }

   186

}

   187

   188

extern int TryEnterDebugSection(void);

   189

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

   190

extern void LeaveDebugSection(void);

   191

   192

void __publish_debug(void)

   193

{

   194

    retain_offset = 0;

   195

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

   196

    if(TryEnterDebugSection()){

   197

        /* Lock buffer */

   198

        long latest_state = AtomicCompareExchange(

   199

            &buffer_state,

   200

            BUFFER_FREE,

   201

            BUFFER_BUSY);

   202

   203

        /* If buffer was free */

   204

        if(latest_state == BUFFER_FREE)

   205

        {

   206

            /* Reset buffer cursor */

   207

            buffer_cursor = debug_buffer;

   208

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

   209

            __for_each_variable_do(BufferDebugDataIterator);

   210

   211

            /* Leave debug section,

   212

             * Trigger asynchronous transmission 

   213

             * (returns immediately) */

   214

            InitiateDebugTransfer(); /* size */

   215

        }

   216

        LeaveDebugSection();

   217

    }else{

   218

        /* when not debugging, do only retain */

   219

        __for_each_variable_do(RetainIterator);

   220

    }

   221

}

   222

   223

#define __RegisterDebugVariable_case_t(TYPENAME) \

   224

        case TYPENAME##_ENUM :\

   225

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

   226

            if(force)\

   227

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

   228

            break;

   229

#define __RegisterDebugVariable_case_p(TYPENAME)\

   230

        case TYPENAME##_P_ENUM :\

   231

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

   232

            if(force)\

   233

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

   234

            break;\

   235

        case TYPENAME##_O_ENUM :\

   236

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

   237

            if(force)\

   238

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

   239

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

   240

            break;

   241

void RegisterDebugVariable(int idx, void* force)

   242

{

   243

    void *varp = NULL;

   244

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

   245

    switch(__find_variable(idx, &varp)){

   246

        ANY(__RegisterDebugVariable_case_t)

   247

        ANY(__RegisterDebugVariable_case_p)

   248

    default:

   249

        break;

   250

    }

   251

}

   252

   253

#define __ResetDebugVariablesIterator_case_t(TYPENAME) \

   254

        case TYPENAME##_ENUM :\

   255

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

   256

            break;

   257

   258

#define __ResetDebugVariablesIterator_case_p(TYPENAME)\

   259

        case TYPENAME##_P_ENUM :\

   260

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

   261

            break;

   262

   263

void ResetDebugVariablesIterator(void* varp, __IEC_types_enum vartype)

   264

{

   265

    /* force debug flag to 0*/

   266

    switch(vartype){

   267

        ANY(__ResetDebugVariablesIterator_case_t)

   268

        ANY(__ResetDebugVariablesIterator_case_p)

   269

    default:

   270

        break;

   271

    }

   272

}

   273

   274

void ResetDebugVariables(void)

   275

{

   276

    __for_each_variable_do(ResetDebugVariablesIterator);

   277

}

   278

   279

void FreeDebugData(void)

   280

{

   281

    /* atomically mark buffer as free */

   282

    long latest_state;

   283

    latest_state = AtomicCompareExchange(

   284

        &buffer_state,

   285

        BUFFER_BUSY,

   286

        BUFFER_FREE);

   287

}

   288

int WaitDebugData(unsigned long *tick);

   289

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

   290

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

   291

    int wait_error = WaitDebugData(tick);

   292

    if(!wait_error){

   293

        *size = buffer_cursor - debug_buffer;

   294

        *buffer = debug_buffer;

   295

    }

   296

    return wait_error;

   297

}

   298