author | Laurent Bessard |
Tue, 05 Mar 2013 17:56:51 +0100 | |
changeset 963 | f1c6b7a6f44b |
parent 954 | ab487d32ce9a |
child 969 | 1950fe687dde |
permissions | -rw-r--r-- |
209
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
1 |
/* |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
2 |
* DEBUGGER code |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
3 |
* |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
4 |
* On "publish", when buffer is free, debugger stores arbitrary variables |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
5 |
* content into, and mark this buffer as filled |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
6 |
* |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
7 |
* |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
8 |
* Buffer content is read asynchronously, (from non real time part), |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
9 |
* and then buffer marked free again. |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
10 |
* |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
11 |
* |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
12 |
* */ |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
13 |
#include "iec_types_all.h" |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
14 |
#include "POUS.h" |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
15 |
/*for memcpy*/ |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
16 |
#include <string.h> |
335
c5f3f71e7260
fixed bug : buffer overflow when debugging PLC with python blocks
greg
parents:
280
diff
changeset
|
17 |
#include <stdio.h> |
209
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
18 |
|
335
c5f3f71e7260
fixed bug : buffer overflow when debugging PLC with python blocks
greg
parents:
280
diff
changeset
|
19 |
#define BUFFER_SIZE %(buffer_size)d |
209
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
20 |
|
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
21 |
/* Atomically accessed variable for buffer state */ |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
22 |
#define BUFFER_FREE 0 |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
23 |
#define BUFFER_BUSY 1 |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
24 |
static long buffer_state = BUFFER_FREE; |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
25 |
|
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
26 |
/* The buffer itself */ |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
27 |
char debug_buffer[BUFFER_SIZE]; |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
28 |
|
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
29 |
/* Buffer's cursor*/ |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
30 |
static char* buffer_cursor = debug_buffer; |
483
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
31 |
static unsigned int retain_offset = 0; |
209
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
32 |
/*** |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
33 |
* Declare programs |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
34 |
**/ |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
35 |
%(programs_declarations)s |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
36 |
|
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
37 |
/*** |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
38 |
* Declare global variables from resources and conf |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
39 |
**/ |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
40 |
%(extern_variables_declarations)s |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
41 |
|
450
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
42 |
typedef void(*__for_each_variable_do_fp)(void*, __IEC_types_enum); |
452
2d0718a05cc7
Reflect changes in iec type definitions in matiec/lib
edouard
parents:
450
diff
changeset
|
43 |
void __for_each_variable_do(__for_each_variable_do_fp fp) |
450
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
44 |
{ |
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
45 |
%(for_each_variable_do_code)s |
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
46 |
} |
209
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
47 |
|
450
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
48 |
__IEC_types_enum __find_variable(unsigned int varindex, void ** varp) |
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
49 |
{ |
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
50 |
switch(varindex){ |
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
51 |
%(find_variable_case_code)s |
452
2d0718a05cc7
Reflect changes in iec type definitions in matiec/lib
edouard
parents:
450
diff
changeset
|
52 |
default: |
2d0718a05cc7
Reflect changes in iec type definitions in matiec/lib
edouard
parents:
450
diff
changeset
|
53 |
*varp = NULL; |
2d0718a05cc7
Reflect changes in iec type definitions in matiec/lib
edouard
parents:
450
diff
changeset
|
54 |
return UNKNOWN_ENUM; |
2d0718a05cc7
Reflect changes in iec type definitions in matiec/lib
edouard
parents:
450
diff
changeset
|
55 |
} |
450
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
56 |
} |
209
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
57 |
|
605
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
58 |
#define __Unpack_case_t(TYPENAME) \ |
450
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
59 |
case TYPENAME##_ENUM :\ |
483
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
60 |
*flags = ((__IEC_##TYPENAME##_t *)varp)->flags;\ |
605
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
61 |
forced_value_p = *real_value_p = &((__IEC_##TYPENAME##_t *)varp)->value;\ |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
62 |
break; |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
63 |
|
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
64 |
#define __Unpack_case_p(TYPENAME)\ |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
65 |
case TYPENAME##_O_ENUM :\ |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
66 |
*flags = __IEC_OUTPUT_FLAG;\ |
450
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
67 |
case TYPENAME##_P_ENUM :\ |
605
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
68 |
*flags |= ((__IEC_##TYPENAME##_p *)varp)->flags;\ |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
69 |
*real_value_p = ((__IEC_##TYPENAME##_p *)varp)->value;\ |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
70 |
forced_value_p = &((__IEC_##TYPENAME##_p *)varp)->fvalue;\ |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
71 |
break; |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
72 |
|
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
73 |
void* UnpackVar(void* varp, __IEC_types_enum vartype, void **real_value_p, char *flags) |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
74 |
{ |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
75 |
void *forced_value_p = NULL; |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
76 |
*flags = 0; |
450
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
77 |
/* find data to copy*/ |
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
78 |
switch(vartype){ |
611 | 79 |
__ANY(__Unpack_case_t) |
80 |
__ANY(__Unpack_case_p) |
|
452
2d0718a05cc7
Reflect changes in iec type definitions in matiec/lib
edouard
parents:
450
diff
changeset
|
81 |
default: |
2d0718a05cc7
Reflect changes in iec type definitions in matiec/lib
edouard
parents:
450
diff
changeset
|
82 |
break; |
450
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
83 |
} |
605
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
84 |
if (*flags & __IEC_FORCE_FLAG) |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
85 |
return forced_value_p; |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
86 |
return *real_value_p; |
483
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
87 |
} |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
88 |
|
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
89 |
void Remind(unsigned int offset, unsigned int count, void * p); |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
90 |
|
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
91 |
void RemindIterator(void* varp, __IEC_types_enum vartype) |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
92 |
{ |
605
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
93 |
void *real_value_p = NULL; |
483
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
94 |
char flags = 0; |
605
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
95 |
UnpackVar(varp, vartype, &real_value_p, &flags); |
483
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
96 |
|
507 | 97 |
if(flags & __IEC_RETAIN_FLAG){ |
450
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
98 |
USINT size = __get_type_enum_size(vartype); |
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
99 |
/* compute next cursor positon*/ |
483
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
100 |
unsigned int next_retain_offset = retain_offset + size; |
450
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
101 |
/* if buffer not full */ |
605
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
102 |
Remind(retain_offset, size, real_value_p); |
483
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
103 |
/* increment cursor according size*/ |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
104 |
retain_offset = next_retain_offset; |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
105 |
} |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
106 |
} |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
107 |
|
580 | 108 |
extern int CheckRetainBuffer(void); |
521
02cb9e5fb6f6
LPC transfer tested, added PLCInfo along MD5 checksum while invoking makefile
edouard
parents:
511
diff
changeset
|
109 |
|
483
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
110 |
void __init_debug(void) |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
111 |
{ |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
112 |
/* init local static vars */ |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
113 |
buffer_cursor = debug_buffer; |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
114 |
retain_offset = 0; |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
115 |
buffer_state = BUFFER_FREE; |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
116 |
/* Iterate over all variables to fill debug buffer */ |
521
02cb9e5fb6f6
LPC transfer tested, added PLCInfo along MD5 checksum while invoking makefile
edouard
parents:
511
diff
changeset
|
117 |
if(CheckRetainBuffer()) |
02cb9e5fb6f6
LPC transfer tested, added PLCInfo along MD5 checksum while invoking makefile
edouard
parents:
511
diff
changeset
|
118 |
__for_each_variable_do(RemindIterator); |
483
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
119 |
retain_offset = 0; |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
120 |
} |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
121 |
|
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
122 |
extern void InitiateDebugTransfer(void); |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
123 |
|
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
124 |
extern unsigned long __tick; |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
125 |
|
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
126 |
void __cleanup_debug(void) |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
127 |
{ |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
128 |
buffer_cursor = debug_buffer; |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
129 |
InitiateDebugTransfer(); |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
130 |
} |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
131 |
|
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
132 |
void __retrieve_debug(void) |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
133 |
{ |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
134 |
} |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
135 |
|
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
136 |
|
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
137 |
void Retain(unsigned int offset, unsigned int count, void * p); |
605
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
138 |
|
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
139 |
inline void BufferIterator(void* varp, __IEC_types_enum vartype, int do_debug) |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
140 |
{ |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
141 |
void *real_value_p = NULL; |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
142 |
void *visible_value_p = NULL; |
483
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
143 |
char flags = 0; |
605
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
144 |
|
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
145 |
visible_value_p = UnpackVar(varp, vartype, &real_value_p, &flags); |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
146 |
|
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
147 |
if(flags & ( __IEC_DEBUG_FLAG | __IEC_RETAIN_FLAG)){ |
483
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
148 |
USINT size = __get_type_enum_size(vartype); |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
149 |
if(flags & __IEC_DEBUG_FLAG){ |
605
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
150 |
/* copy visible variable to buffer */; |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
151 |
if(do_debug){ |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
152 |
/* compute next cursor positon. |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
153 |
No need to check overflow, as BUFFER_SIZE |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
154 |
is computed large enough */ |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
155 |
char* next_cursor = buffer_cursor + size; |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
156 |
/* copy data to the buffer */ |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
157 |
memcpy(buffer_cursor, visible_value_p, size); |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
158 |
/* increment cursor according size*/ |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
159 |
buffer_cursor = next_cursor; |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
160 |
} |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
161 |
/* re-force real value of outputs (M and Q)*/ |
649
c48023b6f0ec
Fixing bug in forcing variables in runtime debug thread
laurent
parents:
611
diff
changeset
|
162 |
if((flags & __IEC_FORCE_FLAG) && (flags & __IEC_OUTPUT_FLAG)){ |
605
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
163 |
memcpy(real_value_p, visible_value_p, size); |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
164 |
} |
450
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
165 |
} |
483
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
166 |
if(flags & __IEC_RETAIN_FLAG){ |
605
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
167 |
/* compute next cursor positon*/ |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
168 |
unsigned int next_retain_offset = retain_offset + size; |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
169 |
/* if buffer not full */ |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
170 |
Retain(retain_offset, size, real_value_p); |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
171 |
/* increment cursor according size*/ |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
172 |
retain_offset = next_retain_offset; |
483
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
173 |
} |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
174 |
} |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
175 |
} |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
176 |
|
605
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
177 |
void DebugIterator(void* varp, __IEC_types_enum vartype){ |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
178 |
BufferIterator(varp, vartype, 1); |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
179 |
} |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
180 |
|
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
181 |
void RetainIterator(void* varp, __IEC_types_enum vartype){ |
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
182 |
BufferIterator(varp, vartype, 0); |
483
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
183 |
} |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
184 |
|
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
185 |
extern int TryEnterDebugSection(void); |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
186 |
extern long AtomicCompareExchange(long*, long, long); |
954 | 187 |
extern long long AtomicCompareExchange64(long long* , long long , long long); |
483
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
188 |
extern void LeaveDebugSection(void); |
580 | 189 |
extern void ValidateRetainBuffer(void); |
190 |
extern void InValidateRetainBuffer(void); |
|
450
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
191 |
|
423 | 192 |
void __publish_debug(void) |
209
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
193 |
{ |
483
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
194 |
retain_offset = 0; |
580 | 195 |
InValidateRetainBuffer(); |
239
112b4bc523b3
Fixed bad IPC choice for debugger/PLC/control thread collaboration
etisserant
parents:
236
diff
changeset
|
196 |
/* Check there is no running debugger re-configuration */ |
112b4bc523b3
Fixed bad IPC choice for debugger/PLC/control thread collaboration
etisserant
parents:
236
diff
changeset
|
197 |
if(TryEnterDebugSection()){ |
112b4bc523b3
Fixed bad IPC choice for debugger/PLC/control thread collaboration
etisserant
parents:
236
diff
changeset
|
198 |
/* Lock buffer */ |
112b4bc523b3
Fixed bad IPC choice for debugger/PLC/control thread collaboration
etisserant
parents:
236
diff
changeset
|
199 |
long latest_state = AtomicCompareExchange( |
112b4bc523b3
Fixed bad IPC choice for debugger/PLC/control thread collaboration
etisserant
parents:
236
diff
changeset
|
200 |
&buffer_state, |
112b4bc523b3
Fixed bad IPC choice for debugger/PLC/control thread collaboration
etisserant
parents:
236
diff
changeset
|
201 |
BUFFER_FREE, |
112b4bc523b3
Fixed bad IPC choice for debugger/PLC/control thread collaboration
etisserant
parents:
236
diff
changeset
|
202 |
BUFFER_BUSY); |
112b4bc523b3
Fixed bad IPC choice for debugger/PLC/control thread collaboration
etisserant
parents:
236
diff
changeset
|
203 |
|
112b4bc523b3
Fixed bad IPC choice for debugger/PLC/control thread collaboration
etisserant
parents:
236
diff
changeset
|
204 |
/* If buffer was free */ |
112b4bc523b3
Fixed bad IPC choice for debugger/PLC/control thread collaboration
etisserant
parents:
236
diff
changeset
|
205 |
if(latest_state == BUFFER_FREE) |
209
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
206 |
{ |
239
112b4bc523b3
Fixed bad IPC choice for debugger/PLC/control thread collaboration
etisserant
parents:
236
diff
changeset
|
207 |
/* Reset buffer cursor */ |
112b4bc523b3
Fixed bad IPC choice for debugger/PLC/control thread collaboration
etisserant
parents:
236
diff
changeset
|
208 |
buffer_cursor = debug_buffer; |
450
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
209 |
/* Iterate over all variables to fill debug buffer */ |
605
2250ed42e306
debugger : forcing %M and %Q variables on each cycle, and rework of code for optimization and concision
Edouard Tisserant
parents:
582
diff
changeset
|
210 |
__for_each_variable_do(DebugIterator); |
239
112b4bc523b3
Fixed bad IPC choice for debugger/PLC/control thread collaboration
etisserant
parents:
236
diff
changeset
|
211 |
|
112b4bc523b3
Fixed bad IPC choice for debugger/PLC/control thread collaboration
etisserant
parents:
236
diff
changeset
|
212 |
/* Leave debug section, |
112b4bc523b3
Fixed bad IPC choice for debugger/PLC/control thread collaboration
etisserant
parents:
236
diff
changeset
|
213 |
* Trigger asynchronous transmission |
112b4bc523b3
Fixed bad IPC choice for debugger/PLC/control thread collaboration
etisserant
parents:
236
diff
changeset
|
214 |
* (returns immediately) */ |
112b4bc523b3
Fixed bad IPC choice for debugger/PLC/control thread collaboration
etisserant
parents:
236
diff
changeset
|
215 |
InitiateDebugTransfer(); /* size */ |
581 | 216 |
}else{ |
217 |
/* when not debugging, do only retain */ |
|
218 |
__for_each_variable_do(RetainIterator); |
|
209
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
219 |
} |
239
112b4bc523b3
Fixed bad IPC choice for debugger/PLC/control thread collaboration
etisserant
parents:
236
diff
changeset
|
220 |
LeaveDebugSection(); |
483
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
221 |
}else{ |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
222 |
/* when not debugging, do only retain */ |
bc26c42d2eec
fixed greg's crap in win32, enhanced debug stability, implemented preliminary retain
edouard
parents:
477
diff
changeset
|
223 |
__for_each_variable_do(RetainIterator); |
209
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
224 |
} |
580 | 225 |
ValidateRetainBuffer(); |
209
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
226 |
} |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
227 |
|
450
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
228 |
#define __RegisterDebugVariable_case_t(TYPENAME) \ |
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
229 |
case TYPENAME##_ENUM :\ |
477
f66a092b6e74
Arbitrary variable forcing
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
458
diff
changeset
|
230 |
((__IEC_##TYPENAME##_t *)varp)->flags |= flags;\ |
f66a092b6e74
Arbitrary variable forcing
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
458
diff
changeset
|
231 |
if(force)\ |
f66a092b6e74
Arbitrary variable forcing
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
458
diff
changeset
|
232 |
((__IEC_##TYPENAME##_t *)varp)->value = *((TYPENAME *)force);\ |
458
dfc6164e4022
Debugger still doesn't work crash less...
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
452
diff
changeset
|
233 |
break; |
450
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
234 |
#define __RegisterDebugVariable_case_p(TYPENAME)\ |
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
235 |
case TYPENAME##_P_ENUM :\ |
477
f66a092b6e74
Arbitrary variable forcing
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
458
diff
changeset
|
236 |
((__IEC_##TYPENAME##_p *)varp)->flags |= flags;\ |
f66a092b6e74
Arbitrary variable forcing
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
458
diff
changeset
|
237 |
if(force)\ |
f66a092b6e74
Arbitrary variable forcing
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
458
diff
changeset
|
238 |
((__IEC_##TYPENAME##_p *)varp)->fvalue = *((TYPENAME *)force);\ |
511 | 239 |
break;\ |
240 |
case TYPENAME##_O_ENUM :\ |
|
241 |
((__IEC_##TYPENAME##_p *)varp)->flags |= flags;\ |
|
582
bb5d0367bf32
Fix typo in plc_debug.c
Edouqrd Tisserant <edouard.tisserant@gmail.com>
parents:
581
diff
changeset
|
242 |
if(force){\ |
511 | 243 |
((__IEC_##TYPENAME##_p *)varp)->fvalue = *((TYPENAME *)force);\ |
244 |
*(((__IEC_##TYPENAME##_p *)varp)->value) = *((TYPENAME *)force);\ |
|
582
bb5d0367bf32
Fix typo in plc_debug.c
Edouqrd Tisserant <edouard.tisserant@gmail.com>
parents:
581
diff
changeset
|
245 |
}\ |
477
f66a092b6e74
Arbitrary variable forcing
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
458
diff
changeset
|
246 |
break; |
f66a092b6e74
Arbitrary variable forcing
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
458
diff
changeset
|
247 |
void RegisterDebugVariable(int idx, void* force) |
209
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
248 |
{ |
452
2d0718a05cc7
Reflect changes in iec type definitions in matiec/lib
edouard
parents:
450
diff
changeset
|
249 |
void *varp = NULL; |
477
f66a092b6e74
Arbitrary variable forcing
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
458
diff
changeset
|
250 |
unsigned char flags = force ? __IEC_DEBUG_FLAG | __IEC_FORCE_FLAG : __IEC_DEBUG_FLAG; |
458
dfc6164e4022
Debugger still doesn't work crash less...
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
452
diff
changeset
|
251 |
switch(__find_variable(idx, &varp)){ |
611 | 252 |
__ANY(__RegisterDebugVariable_case_t) |
253 |
__ANY(__RegisterDebugVariable_case_p) |
|
452
2d0718a05cc7
Reflect changes in iec type definitions in matiec/lib
edouard
parents:
450
diff
changeset
|
254 |
default: |
2d0718a05cc7
Reflect changes in iec type definitions in matiec/lib
edouard
parents:
450
diff
changeset
|
255 |
break; |
450
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
256 |
} |
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
257 |
} |
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
258 |
|
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
259 |
#define __ResetDebugVariablesIterator_case_t(TYPENAME) \ |
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
260 |
case TYPENAME##_ENUM :\ |
477
f66a092b6e74
Arbitrary variable forcing
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
458
diff
changeset
|
261 |
((__IEC_##TYPENAME##_t *)varp)->flags &= ~(__IEC_DEBUG_FLAG|__IEC_FORCE_FLAG);\ |
458
dfc6164e4022
Debugger still doesn't work crash less...
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
452
diff
changeset
|
262 |
break; |
450
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
263 |
|
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
264 |
#define __ResetDebugVariablesIterator_case_p(TYPENAME)\ |
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
265 |
case TYPENAME##_P_ENUM :\ |
582
bb5d0367bf32
Fix typo in plc_debug.c
Edouqrd Tisserant <edouard.tisserant@gmail.com>
parents:
581
diff
changeset
|
266 |
case TYPENAME##_O_ENUM :\ |
477
f66a092b6e74
Arbitrary variable forcing
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
458
diff
changeset
|
267 |
((__IEC_##TYPENAME##_p *)varp)->flags &= ~(__IEC_DEBUG_FLAG|__IEC_FORCE_FLAG);\ |
458
dfc6164e4022
Debugger still doesn't work crash less...
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
452
diff
changeset
|
268 |
break; |
450
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
269 |
|
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
270 |
void ResetDebugVariablesIterator(void* varp, __IEC_types_enum vartype) |
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
271 |
{ |
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
272 |
/* force debug flag to 0*/ |
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
273 |
switch(vartype){ |
611 | 274 |
__ANY(__ResetDebugVariablesIterator_case_t) |
275 |
__ANY(__ResetDebugVariablesIterator_case_p) |
|
452
2d0718a05cc7
Reflect changes in iec type definitions in matiec/lib
edouard
parents:
450
diff
changeset
|
276 |
default: |
2d0718a05cc7
Reflect changes in iec type definitions in matiec/lib
edouard
parents:
450
diff
changeset
|
277 |
break; |
209
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
278 |
} |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
279 |
} |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
280 |
|
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
281 |
void ResetDebugVariables(void) |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
282 |
{ |
450
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
283 |
__for_each_variable_do(ResetDebugVariablesIterator); |
209
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
284 |
} |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
285 |
|
423 | 286 |
void FreeDebugData(void) |
209
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
287 |
{ |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
288 |
/* atomically mark buffer as free */ |
423 | 289 |
long latest_state; |
290 |
latest_state = AtomicCompareExchange( |
|
209
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
291 |
&buffer_state, |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
292 |
BUFFER_BUSY, |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
293 |
BUFFER_FREE); |
08dc3d064cb5
Moved template C code to targets dir. Cleaned up some forgotten print.
etisserant
parents:
diff
changeset
|
294 |
} |
452
2d0718a05cc7
Reflect changes in iec type definitions in matiec/lib
edouard
parents:
450
diff
changeset
|
295 |
int WaitDebugData(unsigned long *tick); |
450
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
296 |
/* Wait until debug data ready and return pointer to it */ |
18583d13f0fa
Preliminary accessor support for debug
Edouard TISSERANT <edouard.tisserant@gmail.com>
parents:
423
diff
changeset
|
297 |
int GetDebugData(unsigned long *tick, unsigned long *size, void **buffer){ |
504 | 298 |
int wait_error = WaitDebugData(tick); |
299 |
if(!wait_error){ |
|
502 | 300 |
*size = buffer_cursor - debug_buffer; |
301 |
*buffer = debug_buffer; |
|
302 |
} |
|
504 | 303 |
return wait_error; |
304 |
} |
|
305 |
||
906
de452d65865c
Python runtime now dlopens shared library immediatly after transfer, and release it only immediately before reloading a new one. This is probably going to reveal lot of dirty cleanups during start/stop cycles.
Edouard Tisserant
parents:
649
diff
changeset
|
306 |
|
910
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
307 |
/* LOGGING |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
308 |
*/ |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
309 |
|
917 | 310 |
#define LOG_LEVELS 4 |
311 |
#define LOG_CRITICAL 0 |
|
312 |
#define LOG_WARNING 1 |
|
313 |
#define LOG_INFO 2 |
|
923
6ef6e0b3a908
Fixed crash (segfault) when logging debug messages
Edouard Tisserant
parents:
921
diff
changeset
|
314 |
#define LOG_DEBUG 3 |
917 | 315 |
|
944
52a17be9c4d1
Introduce Beremiz Native POU library. Now LOGGER POU is part of Beremiz' native POU library
Edouard Tisserant
parents:
923
diff
changeset
|
316 |
#ifndef LOG_BUFFER_SIZE |
910
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
317 |
#define LOG_BUFFER_SIZE (1<<14) /*16Ko*/ |
944
52a17be9c4d1
Introduce Beremiz Native POU library. Now LOGGER POU is part of Beremiz' native POU library
Edouard Tisserant
parents:
923
diff
changeset
|
318 |
#endif |
910
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
319 |
#define LOG_BUFFER_MASK (LOG_BUFFER_SIZE-1) |
917 | 320 |
static char LogBuff[LOG_LEVELS][LOG_BUFFER_SIZE]; |
321 |
void inline copy_to_log(uint8_t level, uint32_t buffpos, void* buf, uint32_t size){ |
|
910
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
322 |
if(buffpos + size < LOG_BUFFER_SIZE){ |
917 | 323 |
memcpy(&LogBuff[level][buffpos], buf, size); |
910
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
324 |
}else{ |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
325 |
uint32_t remaining = LOG_BUFFER_SIZE - buffpos - 1; |
917 | 326 |
memcpy(&LogBuff[level][buffpos], buf, remaining); |
327 |
memcpy(LogBuff[level], buf + remaining, size - remaining); |
|
328 |
} |
|
329 |
} |
|
330 |
void inline copy_from_log(uint8_t level, uint32_t buffpos, void* buf, uint32_t size){ |
|
910
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
331 |
if(buffpos + size < LOG_BUFFER_SIZE){ |
917 | 332 |
memcpy(buf, &LogBuff[level][buffpos], size); |
910
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
333 |
}else{ |
911
ffa24427396a
Log redirected to console, dump of all available log to console when connecting to PLC
Edouard Tisserant
parents:
910
diff
changeset
|
334 |
uint32_t remaining = LOG_BUFFER_SIZE - buffpos; |
917 | 335 |
memcpy(buf, &LogBuff[level][buffpos], remaining); |
336 |
memcpy(buf + remaining, LogBuff[level], size - remaining); |
|
910
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
337 |
} |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
338 |
} |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
339 |
|
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
340 |
/* Log buffer structure |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
341 |
|
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
342 |
|<-Tail1.msgsize->|<-sizeof(mTail)->|<--Tail2.msgsize-->|<-sizeof(mTail)->|... |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
343 |
| Message1 Body | Tail1 | Message2 Body | Tail2 | |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
344 |
|
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
345 |
*/ |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
346 |
typedef struct { |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
347 |
uint32_t msgidx; |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
348 |
uint32_t msgsize; |
921 | 349 |
unsigned long tick; |
350 |
IEC_TIME time; |
|
910
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
351 |
} mTail; |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
352 |
|
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
353 |
/* Log cursor : 64b |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
354 |
|63 ... 32|31 ... 0| |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
355 |
| Message | Buffer | |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
356 |
| counter | Index | */ |
917 | 357 |
static uint64_t LogCursor[LOG_LEVELS] = {0x0,0x0,0x0,0x0}; |
910
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
358 |
|
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
359 |
/* Store one log message of give size */ |
917 | 360 |
int LogMessage(uint8_t level, char* buf, uint32_t size){ |
910
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
361 |
if(size < LOG_BUFFER_SIZE - sizeof(mTail)){ |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
362 |
uint32_t buffpos; |
921 | 363 |
uint64_t new_cursor, old_cursor; |
364 |
||
910
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
365 |
mTail tail; |
921 | 366 |
tail.msgsize = size; |
367 |
tail.tick = __tick; |
|
368 |
PLC_GetTime(&tail.time); |
|
369 |
||
910
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
370 |
/* We cannot increment both msg index and string pointer |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
371 |
in a single atomic operation but we can detect having been interrupted. |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
372 |
So we can try with atomic compare and swap in a loop until operation |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
373 |
succeeds non interrupted */ |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
374 |
do{ |
917 | 375 |
old_cursor = LogCursor[level]; |
910
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
376 |
buffpos = (uint32_t)old_cursor; |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
377 |
tail.msgidx = (old_cursor >> 32); |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
378 |
new_cursor = ((uint64_t)(tail.msgidx + 1)<<32) |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
379 |
| (uint64_t)((buffpos + size + sizeof(mTail)) & LOG_BUFFER_MASK); |
954 | 380 |
}while(AtomicCompareExchange64( |
381 |
(long long*)&LogCursor[level], |
|
382 |
(long long)old_cursor, |
|
383 |
(long long)new_cursor)!=old_cursor); |
|
917 | 384 |
|
385 |
copy_to_log(level, buffpos, buf, size); |
|
386 |
copy_to_log(level, (buffpos + size) & LOG_BUFFER_MASK, &tail, sizeof(mTail)); |
|
910
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
387 |
|
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
388 |
return 1; /* Success */ |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
389 |
}else{ |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
390 |
char mstr[] = "Logging error : message too big"; |
917 | 391 |
LogMessage(LOG_CRITICAL, mstr, sizeof(mstr)); |
910
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
392 |
} |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
393 |
return 0; |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
394 |
} |
906
de452d65865c
Python runtime now dlopens shared library immediatly after transfer, and release it only immediately before reloading a new one. This is probably going to reveal lot of dirty cleanups during start/stop cycles.
Edouard Tisserant
parents:
649
diff
changeset
|
395 |
|
917 | 396 |
uint32_t GetLogCount(uint8_t level){ |
397 |
return (uint64_t)LogCursor[level] >> 32; |
|
910
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
398 |
} |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
399 |
|
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
400 |
/* Return message size and content */ |
921 | 401 |
uint32_t GetLogMessage(uint8_t level, uint32_t msgidx, char* buf, uint32_t max_size, uint32_t* tick, uint32_t* tv_sec, uint32_t* tv_nsec){ |
917 | 402 |
uint64_t cursor = LogCursor[level]; |
910
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
403 |
if(cursor){ |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
404 |
/* seach cursor */ |
911
ffa24427396a
Log redirected to console, dump of all available log to console when connecting to PLC
Edouard Tisserant
parents:
910
diff
changeset
|
405 |
uint32_t stailpos = (uint32_t)cursor; |
910
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
406 |
uint32_t smsgidx; |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
407 |
mTail tail; |
911
ffa24427396a
Log redirected to console, dump of all available log to console when connecting to PLC
Edouard Tisserant
parents:
910
diff
changeset
|
408 |
tail.msgidx = cursor >> 32; |
ffa24427396a
Log redirected to console, dump of all available log to console when connecting to PLC
Edouard Tisserant
parents:
910
diff
changeset
|
409 |
tail.msgsize = 0; |
910
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
410 |
|
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
411 |
/* Message search loop */ |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
412 |
do { |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
413 |
smsgidx = tail.msgidx; |
911
ffa24427396a
Log redirected to console, dump of all available log to console when connecting to PLC
Edouard Tisserant
parents:
910
diff
changeset
|
414 |
stailpos = (stailpos - sizeof(mTail) - tail.msgsize ) & LOG_BUFFER_MASK; |
917 | 415 |
copy_from_log(level, stailpos, &tail, sizeof(mTail)); |
911
ffa24427396a
Log redirected to console, dump of all available log to console when connecting to PLC
Edouard Tisserant
parents:
910
diff
changeset
|
416 |
}while((tail.msgidx == smsgidx - 1) && (tail.msgidx > msgidx)); |
910
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
417 |
|
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
418 |
if(tail.msgidx == msgidx){ |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
419 |
uint32_t sbuffpos = (stailpos - tail.msgsize ) & LOG_BUFFER_MASK; |
921 | 420 |
uint32_t totalsize = tail.msgsize; |
421 |
*tick = tail.tick; |
|
422 |
*tv_sec = tail.time.tv_sec; |
|
423 |
*tv_nsec = tail.time.tv_nsec; |
|
424 |
copy_from_log(level, sbuffpos, buf, |
|
425 |
totalsize > max_size ? max_size : totalsize); |
|
910
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
426 |
return totalsize; |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
427 |
} |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
428 |
} |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
429 |
return 0; |
f6d06bdd31e8
Experimental logging feature in PLC debug
Edouard Tisserant
parents:
906
diff
changeset
|
430 |
} |