1

/**

     2

 * LPC specific code

     3

 **/

     4

     5

#include <string.h>

     6

#include <app_glue.h>

     7

     8

extern unsigned long idLen;

     9

extern unsigned char *idBuf;

    10

    11

static unsigned char RetainedIdBuf[128] NONVOLATILE;

    12

static unsigned char retain_buffer[RETAIN_BUFFER_SIZE] NONVOLATILE;

    13

    14

#define LOG_BUFFER_SIZE (1<<10) /*1Ko*/

    15

#define LOG_BUFFER_ATTRS NONVOLATILE

    16

    17

static int debug_locked = 0;

    18

static int _DebugDataAvailable = 0;

    19

static unsigned long __debug_tick;

    20

    21

void LPC_GetTime(IEC_TIME*);

    22

void LPC_SetTimer(unsigned long long next, unsigned long long period);

    23

    24

long AtomicCompareExchange(long* atomicvar,long compared, long exchange)

    25

{

    26

	/* No need for real atomic op on LPC,

    27

	 * no possible preemption between debug and PLC */

    28

	long res = *atomicvar;

    29

	if(res == compared){

    30

		*atomicvar = exchange;

    31

	}

    32

	return res;

    33

}

    34

    36

{

    37

	/* No need for real atomic op on LPC,

    38

	 * no possible preemption between debug and PLC */

    39

	long long res = *atomicvar;

    40

	if(res == compared){

    41

		*atomicvar = exchange;

    42

	}

    43

	return res;

    44

}

    45

    46

    47

void PLC_GetTime(IEC_TIME *CURRENT_TIME)

    48

{

    49

	/* Call target GetTime function */

    50

	LPC_GetTime(CURRENT_TIME);

    51

}

    52

    53

void PLC_SetTimer(unsigned long long next, unsigned long long period)

    54

{

    55

	LPC_SetTimer(next, period);

    56

}

    57

    58

int startPLC(int argc,char **argv)

    59

{

    60

	if(__init(argc,argv) == 0){

    61

		PLC_SetTimer(0, Ttick);

    62

		return 0;

    63

	}else{

    64

		return 1;

    65

	}

    66

}

    67

    68

int TryEnterDebugSection(void)

    69

{

    70

    if(!debug_locked && __DEBUG){

    71

        debug_locked = 1;

    72

		return 1;

    73

    }

    74

    return 0;

    75

}

    76

    77

void LeaveDebugSection(void)

    78

{

    79

        debug_locked = 0;

    80

}

    81

    82

int stopPLC(void)

    83

{

    84

    __cleanup();

    85

    return 0;

    86

}

    87

    88

/* from plc_debugger.c */

    89

int WaitDebugData(unsigned long *tick)

    90

{

    91

    /* no blocking call on LPC */

    92

    if(_DebugDataAvailable && !debug_locked){

    93

        /* returns 0 on success */

    94

        *tick = __debug_tick;

    95

        _DebugDataAvailable = 0;

    96

        return 0;

    97

    }

    98

    return 1;

    99

}

   100

   101

/* Called by PLC thread when debug_publish finished

   102

 * This is supposed to unlock debugger thread in WaitDebugData*/

   103

void InitiateDebugTransfer(void)

   104

{

   105

    /* remember tick */

   106

    __debug_tick = __tick;

   107

    _DebugDataAvailable = 1;

   108

}

   109

   110

void suspendDebug(int disable)

   111

{

   112

    /* Prevent PLC to enter debug code */

   113

    __DEBUG = !disable;

   114

    debug_locked = !disable;

   115

}

   116

   117

void resumeDebug(void)

   118

{

   119

    /* Let PLC enter debug code */

   120

    __DEBUG = 1;

   121

    debug_locked = 0;

   122

}

   123

   124

void ValidateRetainBuffer(void)

   125

{

   126

        memcpy(RetainedIdBuf, idBuf, idLen);

   127

}

   128

   129

void InValidateRetainBuffer(void)

   130

{

   131

    /* invalidate that buffer */

   132

    RetainedIdBuf[0] = 0;

   133

}

   134

   135

int CheckRetainBuffer(void)

   136

{

   137

	/* compare RETAIN ID buffer with MD5 */

   138

    /* return true if identical */

   139

    int res = memcmp(RetainedIdBuf, idBuf, idLen) == 0;

   140

    return res;

   141

}

   142

   143

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

   144

{

   145

    if(offset + count < RETAIN_BUFFER_SIZE)

   146

        /* write in RETAIN buffer at offset*/

   147

        memcpy(&retain_buffer[offset], p, count);

   148

}

   149

   150

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

   151

{

   152

    if(offset + count < RETAIN_BUFFER_SIZE)

   153

        /* read at offset in RETAIN buffer */

   154

        memcpy(p, &retain_buffer[offset], count);

   155

}