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;

    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 :\

    63

            break;

    64

    65

#define __BufferDebugDataIterator_case_p(TYPENAME)\

    66

        case TYPENAME##_P_ENUM :\

    73

    /* find data to copy*/

    74

    switch(vartype){

    75

        ANY(__BufferDebugDataIterator_case_t)

    76

        ANY(__BufferDebugDataIterator_case_p)

    77

    default:

    78

        break;

    79

    }

    91

        USINT size = __get_type_enum_size(vartype);

    92

        /* compute next cursor positon*/

    94

        /* if buffer not full */

   162

        }

   184

   185

void __publish_debug(void)

   186

{

   188

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

   189

    if(TryEnterDebugSection()){

   190

        /* Lock buffer */

   191

        long latest_state = AtomicCompareExchange(

   192

            &buffer_state,

   193

            BUFFER_FREE,

   194

            BUFFER_BUSY);

   195

   196

        /* If buffer was free */

   197

        if(latest_state == BUFFER_FREE)

   198

        {

   199

            /* Reset buffer cursor */

   200

            buffer_cursor = debug_buffer;

   201

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

   202

            __for_each_variable_do(BufferDebugDataIterator);

   203

   204

            /* Leave debug section,

   205

             * Trigger asynchronous transmission 

   206

             * (returns immediately) */

   207

            InitiateDebugTransfer(); /* size */

   208

        }

   209

        LeaveDebugSection();

   213

    }

   214

}

   215

   216

#define __RegisterDebugVariable_case_t(TYPENAME) \

   217

        case TYPENAME##_ENUM :\

   218

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

   219

            if(force)\

   220

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

   221

            break;

   222

#define __RegisterDebugVariable_case_p(TYPENAME)\

   223

        case TYPENAME##_P_ENUM :\

   224

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

   225

            if(force)\

   226

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

   227

            break;

   228

void RegisterDebugVariable(int idx, void* force)

   229

{

   230

    void *varp = NULL;

   231

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

   232

    switch(__find_variable(idx, &varp)){

   233

        ANY(__RegisterDebugVariable_case_t)

   234

        ANY(__RegisterDebugVariable_case_p)

   235

    default:

   236

        break;

   237

    }

   238

}

   239

   240

#define __ResetDebugVariablesIterator_case_t(TYPENAME) \

   241

        case TYPENAME##_ENUM :\

   242

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

   243

            break;

   244

   245

#define __ResetDebugVariablesIterator_case_p(TYPENAME)\

   246

        case TYPENAME##_P_ENUM :\

   247

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

   248

            break;

   249

   250

void ResetDebugVariablesIterator(void* varp, __IEC_types_enum vartype)

   251

{

   252

    /* force debug flag to 0*/

   253

    switch(vartype){

   254

        ANY(__ResetDebugVariablesIterator_case_t)

   255

        ANY(__ResetDebugVariablesIterator_case_p)

   256

    default:

   257

        break;

   258

    }

   259

}

   260

   261

void ResetDebugVariables(void)

   262

{

   263

    __for_each_variable_do(ResetDebugVariablesIterator);

   264

}

   265

   266

void FreeDebugData(void)

   267

{

   268

    /* atomically mark buffer as free */

   269

    long latest_state;

   270

    latest_state = AtomicCompareExchange(

   271

        &buffer_state,

   272

        BUFFER_BUSY,

   273

        BUFFER_FREE);

   274

}

   275

int WaitDebugData(unsigned long *tick);

   276

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

   277

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

   278

    int res = WaitDebugData(tick);

   279

    *size = buffer_cursor - debug_buffer;

   280

    *buffer = debug_buffer;

   281

    return res;

   282

}

   283