emfrp 0.1.1 → 0.1.2
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/README.md +1 -1
- data/examples/LCDClock/LCDClock.c +580 -0
- data/examples/LCDClock/LCDClock.h +6 -0
- data/examples/LCDClock/LCDClock.mfrp +93 -0
- data/examples/LCDClock/LCDClockMain.c +42 -0
- data/examples/LCDClock/LCDClock_LPC1768.bin +0 -0
- data/examples/LCDClock/README.md +24 -0
- data/examples/LCDClock/graph.dot +55 -0
- data/examples/LCDClock/graph.png +0 -0
- data/lib/emfrp/parser/misc.rb +1 -1
- data/lib/emfrp/version.rb +1 -1
- data/tests/compiler/LCDClock/LCDClock.mfrp +90 -0
- data/tests/compiler/LCDClock/LCDClockMain.c +26 -0
- data/tests/compiler/LCDClock/Rakefile +2 -0
- data/tests/compiler/LCDClock/actual_out.txt +60 -0
- data/tests/compiler/LCDClock/expected_out.txt +60 -0
- data/tests/compiler/LCDClock/in.txt +60 -0
- data/tests/compiler/UseData/UseData.mfrp +3 -3
- metadata +16 -2
checksums.yaml
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
---
|
|
2
2
|
SHA1:
|
|
3
|
-
metadata.gz:
|
|
4
|
-
data.tar.gz:
|
|
3
|
+
metadata.gz: 8c76aeb70edc85f68ce0412805037f3edd13f585
|
|
4
|
+
data.tar.gz: b2ea35157930fd7911dfaf3a5ece84ac0dfbe6ad
|
|
5
5
|
SHA512:
|
|
6
|
-
metadata.gz:
|
|
7
|
-
data.tar.gz:
|
|
6
|
+
metadata.gz: d43fd34857af5a6a55293fc5b1ccdb699fb468cf1d9b3cbc5b7b39dba9c51a7e077939536c60c621e82b10cff3404780892461cd2f6ed2a08de39b613c0db23f
|
|
7
|
+
data.tar.gz: b1f3486218100ed207900d54c26797ed5d2c17dcadfdf0cc63b4405b65d46b01e3d0f4482bd42faa241e772fcfdabe790414dd068288d6ffb012d4ce88b8503f
|
data/README.md
CHANGED
|
@@ -0,0 +1,580 @@
|
|
|
1
|
+
#include "LCDClock.h"
|
|
2
|
+
/* Primitive functions (Macros) */
|
|
3
|
+
#define _anpersand_anpersand(a, b) (a && b)
|
|
4
|
+
#define _eq__eq_(a, b) (a == b)
|
|
5
|
+
#define _exclamation__eq_(a, b) (a != b)
|
|
6
|
+
#define _parcent_(a, b) (a % b)
|
|
7
|
+
#define _plus_(a, b) (a + b)
|
|
8
|
+
#define _lt_(a, b) (a < b)
|
|
9
|
+
#define _slash_(a, b) (a / b)
|
|
10
|
+
#define _at__exclamation_(a) (!a)
|
|
11
|
+
/* Data types */
|
|
12
|
+
struct Time{
|
|
13
|
+
int mark;
|
|
14
|
+
union {
|
|
15
|
+
struct {
|
|
16
|
+
int member0;
|
|
17
|
+
int member1;
|
|
18
|
+
int member2;
|
|
19
|
+
}Time;
|
|
20
|
+
}value;
|
|
21
|
+
};
|
|
22
|
+
struct Tuple3_Int_Int_Int{
|
|
23
|
+
int mark;
|
|
24
|
+
union {
|
|
25
|
+
struct {
|
|
26
|
+
int member0;
|
|
27
|
+
int member1;
|
|
28
|
+
int member2;
|
|
29
|
+
}Tuple3;
|
|
30
|
+
}value;
|
|
31
|
+
};
|
|
32
|
+
struct Tuple3_Bool_Bool_Bool{
|
|
33
|
+
int mark;
|
|
34
|
+
union {
|
|
35
|
+
struct {
|
|
36
|
+
int member0;
|
|
37
|
+
int member1;
|
|
38
|
+
int member2;
|
|
39
|
+
}Tuple3;
|
|
40
|
+
}value;
|
|
41
|
+
};
|
|
42
|
+
/* Global variables */
|
|
43
|
+
int node_memory_btnMode[2];
|
|
44
|
+
int node_memory_btnNext[2];
|
|
45
|
+
int node_memory_btnRotate[2];
|
|
46
|
+
int node_memory_pulse100ms[2];
|
|
47
|
+
int node_memory_counter[2];
|
|
48
|
+
int node_memory_curMode[2];
|
|
49
|
+
int node_memory_curPos[2];
|
|
50
|
+
int node_memory_pulse1s[2];
|
|
51
|
+
int node_memory_flash[2];
|
|
52
|
+
struct Tuple3_Int_Int_Int* node_memory_anonymous69880537178160[2];
|
|
53
|
+
struct Tuple3_Bool_Bool_Bool* node_memory_anonymous69880541228320[2];
|
|
54
|
+
int node_memory_dh[2];
|
|
55
|
+
int node_memory_dm[2];
|
|
56
|
+
int node_memory_ds[2];
|
|
57
|
+
int node_memory_maskHour[2];
|
|
58
|
+
int node_memory_maskMin[2];
|
|
59
|
+
int node_memory_maskSec[2];
|
|
60
|
+
struct Time* node_memory_curTime[2];
|
|
61
|
+
int node_memory_hour[2];
|
|
62
|
+
int node_memory_min[2];
|
|
63
|
+
int node_memory_sec[2];
|
|
64
|
+
struct Time memory_Time[3];
|
|
65
|
+
int size_Time = 3;
|
|
66
|
+
int counter_Time = 0;
|
|
67
|
+
struct Tuple3_Int_Int_Int memory_Tuple3_Int_Int_Int[1];
|
|
68
|
+
int size_Tuple3_Int_Int_Int = 1;
|
|
69
|
+
int counter_Tuple3_Int_Int_Int = 0;
|
|
70
|
+
struct Tuple3_Bool_Bool_Bool memory_Tuple3_Bool_Bool_Bool[1];
|
|
71
|
+
int size_Tuple3_Bool_Bool_Bool = 1;
|
|
72
|
+
int counter_Tuple3_Bool_Bool_Bool = 0;
|
|
73
|
+
int Counter = 1;
|
|
74
|
+
int NodeSize = 17;
|
|
75
|
+
/* Static prototypes */
|
|
76
|
+
static struct Time* Time_0(int, int, int);
|
|
77
|
+
static void mark_Time(struct Time*, int);
|
|
78
|
+
static struct Tuple3_Int_Int_Int* Tuple3_0(int, int, int);
|
|
79
|
+
static void mark_Tuple3_Int_Int_Int(struct Tuple3_Int_Int_Int*, int);
|
|
80
|
+
static struct Tuple3_Bool_Bool_Bool* Tuple3_1(int, int, int);
|
|
81
|
+
static void mark_Tuple3_Bool_Bool_Bool(struct Tuple3_Bool_Bool_Bool*, int);
|
|
82
|
+
static int init_btnMode();
|
|
83
|
+
static int init_btnNext();
|
|
84
|
+
static int init_btnRotate();
|
|
85
|
+
static int node_counter(int, int, int*);
|
|
86
|
+
static int init_counter();
|
|
87
|
+
static int node_curMode(int, int, int, int*);
|
|
88
|
+
static int init_curMode();
|
|
89
|
+
static int node_curPos(int, int, int, int*);
|
|
90
|
+
static int init_curPos();
|
|
91
|
+
static int node_pulse1s(int, int, int*);
|
|
92
|
+
static int node_flash(int, int*);
|
|
93
|
+
static int node_anonymous69880537178160(int, int, int, int, struct Tuple3_Int_Int_Int**);
|
|
94
|
+
static int node_anonymous69880541228320(int, int, int, struct Tuple3_Bool_Bool_Bool**);
|
|
95
|
+
static int node_dh(struct Tuple3_Int_Int_Int*, int*);
|
|
96
|
+
static int node_dm(struct Tuple3_Int_Int_Int*, int*);
|
|
97
|
+
static int node_ds(struct Tuple3_Int_Int_Int*, int*);
|
|
98
|
+
static int node_maskHour(struct Tuple3_Bool_Bool_Bool*, int*);
|
|
99
|
+
static int node_maskMin(struct Tuple3_Bool_Bool_Bool*, int*);
|
|
100
|
+
static int node_maskSec(struct Tuple3_Bool_Bool_Bool*, int*);
|
|
101
|
+
static int node_curTime(int, struct Time*, int, int, int, struct Time**);
|
|
102
|
+
static struct Time* init_curTime();
|
|
103
|
+
static int node_hour(struct Time*, int*);
|
|
104
|
+
static int init_hour();
|
|
105
|
+
static int node_min(struct Time*, int*);
|
|
106
|
+
static int init_min();
|
|
107
|
+
static int node_sec(struct Time*, int*);
|
|
108
|
+
static int init_sec();
|
|
109
|
+
static struct Time* roundingTime_0(struct Time*, int, int, int);
|
|
110
|
+
static struct Time* proceedTime_0(struct Time*);
|
|
111
|
+
static int editable_0(int);
|
|
112
|
+
static int positiveEdge_0(int, int);
|
|
113
|
+
static int nextMode_0(int);
|
|
114
|
+
static int nextPos_0(int);
|
|
115
|
+
static void refreshMark();
|
|
116
|
+
extern void Input(int*, int*, int*, int*);
|
|
117
|
+
extern void Output(int*, int*, int*, int*, int*, int*);
|
|
118
|
+
/* Functions, Constructors, GCMarkers, etc... */
|
|
119
|
+
static struct Time* Time_0(int member0, int member1, int member2) {
|
|
120
|
+
struct Time* x;
|
|
121
|
+
while (1) {
|
|
122
|
+
counter_Time++;
|
|
123
|
+
counter_Time %= size_Time;
|
|
124
|
+
if (memory_Time[counter_Time].mark < Counter) { x = memory_Time + counter_Time; break; }
|
|
125
|
+
}
|
|
126
|
+
x->value.Time.member0 = member0;
|
|
127
|
+
x->value.Time.member1 = member1;
|
|
128
|
+
x->value.Time.member2 = member2;
|
|
129
|
+
return x;
|
|
130
|
+
}
|
|
131
|
+
static void mark_Time(struct Time* x, int mark) {
|
|
132
|
+
x->mark = mark;
|
|
133
|
+
}
|
|
134
|
+
static struct Tuple3_Int_Int_Int* Tuple3_0(int member0, int member1, int member2) {
|
|
135
|
+
struct Tuple3_Int_Int_Int* x;
|
|
136
|
+
while (1) {
|
|
137
|
+
counter_Tuple3_Int_Int_Int++;
|
|
138
|
+
counter_Tuple3_Int_Int_Int %= size_Tuple3_Int_Int_Int;
|
|
139
|
+
if (memory_Tuple3_Int_Int_Int[counter_Tuple3_Int_Int_Int].mark < Counter) { x = memory_Tuple3_Int_Int_Int + counter_Tuple3_Int_Int_Int; break; }
|
|
140
|
+
}
|
|
141
|
+
x->value.Tuple3.member0 = member0;
|
|
142
|
+
x->value.Tuple3.member1 = member1;
|
|
143
|
+
x->value.Tuple3.member2 = member2;
|
|
144
|
+
return x;
|
|
145
|
+
}
|
|
146
|
+
static void mark_Tuple3_Int_Int_Int(struct Tuple3_Int_Int_Int* x, int mark) {
|
|
147
|
+
x->mark = mark;
|
|
148
|
+
}
|
|
149
|
+
static struct Tuple3_Bool_Bool_Bool* Tuple3_1(int member0, int member1, int member2) {
|
|
150
|
+
struct Tuple3_Bool_Bool_Bool* x;
|
|
151
|
+
while (1) {
|
|
152
|
+
counter_Tuple3_Bool_Bool_Bool++;
|
|
153
|
+
counter_Tuple3_Bool_Bool_Bool %= size_Tuple3_Bool_Bool_Bool;
|
|
154
|
+
if (memory_Tuple3_Bool_Bool_Bool[counter_Tuple3_Bool_Bool_Bool].mark < Counter) { x = memory_Tuple3_Bool_Bool_Bool + counter_Tuple3_Bool_Bool_Bool; break; }
|
|
155
|
+
}
|
|
156
|
+
x->value.Tuple3.member0 = member0;
|
|
157
|
+
x->value.Tuple3.member1 = member1;
|
|
158
|
+
x->value.Tuple3.member2 = member2;
|
|
159
|
+
return x;
|
|
160
|
+
}
|
|
161
|
+
static void mark_Tuple3_Bool_Bool_Bool(struct Tuple3_Bool_Bool_Bool* x, int mark) {
|
|
162
|
+
x->mark = mark;
|
|
163
|
+
}
|
|
164
|
+
static int init_btnMode() {
|
|
165
|
+
return 0;
|
|
166
|
+
}
|
|
167
|
+
static int init_btnNext() {
|
|
168
|
+
return 0;
|
|
169
|
+
}
|
|
170
|
+
static int init_btnRotate() {
|
|
171
|
+
return 0;
|
|
172
|
+
}
|
|
173
|
+
static int node_counter(int pulse100ms, int counter_at_last, int* output) {
|
|
174
|
+
int _tmp000;
|
|
175
|
+
if (pulse100ms == 1) {
|
|
176
|
+
_tmp000 = _plus_(counter_at_last, 1);
|
|
177
|
+
}
|
|
178
|
+
else if (pulse100ms == 0) {
|
|
179
|
+
_tmp000 = counter_at_last;
|
|
180
|
+
}
|
|
181
|
+
*output = _parcent_(_tmp000, 10);
|
|
182
|
+
return 1;
|
|
183
|
+
}
|
|
184
|
+
static int init_counter() {
|
|
185
|
+
return 0;
|
|
186
|
+
}
|
|
187
|
+
static int node_curMode(int btnMode_at_last, int btnMode, int curMode_at_last, int* output) {
|
|
188
|
+
int _tmp002;
|
|
189
|
+
int _tmp001;
|
|
190
|
+
_tmp002 = positiveEdge_0(btnMode_at_last, btnMode);
|
|
191
|
+
if (_tmp002 == 1) {
|
|
192
|
+
_tmp001 = nextMode_0(curMode_at_last);
|
|
193
|
+
}
|
|
194
|
+
else if (_tmp002 == 0) {
|
|
195
|
+
_tmp001 = curMode_at_last;
|
|
196
|
+
}
|
|
197
|
+
*output = _tmp001;
|
|
198
|
+
return 1;
|
|
199
|
+
}
|
|
200
|
+
static int init_curMode() {
|
|
201
|
+
return 0;
|
|
202
|
+
}
|
|
203
|
+
static int node_curPos(int btnNext_at_last, int btnNext, int curPos_at_last, int* output) {
|
|
204
|
+
int _tmp004;
|
|
205
|
+
int _tmp003;
|
|
206
|
+
_tmp004 = positiveEdge_0(btnNext_at_last, btnNext);
|
|
207
|
+
if (_tmp004 == 1) {
|
|
208
|
+
_tmp003 = nextPos_0(curPos_at_last);
|
|
209
|
+
}
|
|
210
|
+
else if (_tmp004 == 0) {
|
|
211
|
+
_tmp003 = curPos_at_last;
|
|
212
|
+
}
|
|
213
|
+
*output = _tmp003;
|
|
214
|
+
return 1;
|
|
215
|
+
}
|
|
216
|
+
static int init_curPos() {
|
|
217
|
+
return 0;
|
|
218
|
+
}
|
|
219
|
+
static int node_pulse1s(int counter, int counter_at_last, int* output) {
|
|
220
|
+
*output = _anpersand_anpersand(_eq__eq_(counter, 0), _exclamation__eq_(counter_at_last, 0));
|
|
221
|
+
return 1;
|
|
222
|
+
}
|
|
223
|
+
static int node_flash(int counter, int* output) {
|
|
224
|
+
*output = _lt_(counter, 5);
|
|
225
|
+
return 1;
|
|
226
|
+
}
|
|
227
|
+
static int node_anonymous69880537178160(int curMode, int btnRotate_at_last, int btnRotate, int curPos, struct Tuple3_Int_Int_Int** output) {
|
|
228
|
+
int _tmp006;
|
|
229
|
+
struct Tuple3_Int_Int_Int* _tmp005;
|
|
230
|
+
_tmp006 = _anpersand_anpersand(editable_0(curMode), positiveEdge_0(btnRotate_at_last, btnRotate));
|
|
231
|
+
if (_tmp006 == 1) {
|
|
232
|
+
struct Tuple3_Int_Int_Int* _tmp007;
|
|
233
|
+
if (curPos == 0) {
|
|
234
|
+
_tmp007 = Tuple3_0(1, 0, 0);
|
|
235
|
+
}
|
|
236
|
+
else if (curPos == 1) {
|
|
237
|
+
_tmp007 = Tuple3_0(0, 1, 0);
|
|
238
|
+
}
|
|
239
|
+
else if (curPos == 2) {
|
|
240
|
+
_tmp007 = Tuple3_0(0, 0, 1);
|
|
241
|
+
}
|
|
242
|
+
_tmp005 = _tmp007;
|
|
243
|
+
}
|
|
244
|
+
else if (_tmp006 == 0) {
|
|
245
|
+
_tmp005 = Tuple3_0(0, 0, 0);
|
|
246
|
+
}
|
|
247
|
+
*output = _tmp005;
|
|
248
|
+
return 1;
|
|
249
|
+
}
|
|
250
|
+
static int node_anonymous69880541228320(int curMode, int flash, int curPos, struct Tuple3_Bool_Bool_Bool** output) {
|
|
251
|
+
int _tmp009;
|
|
252
|
+
struct Tuple3_Bool_Bool_Bool* _tmp008;
|
|
253
|
+
_tmp009 = _anpersand_anpersand(editable_0(curMode), flash);
|
|
254
|
+
if (_tmp009 == 1) {
|
|
255
|
+
struct Tuple3_Bool_Bool_Bool* _tmp010;
|
|
256
|
+
if (curPos == 0) {
|
|
257
|
+
_tmp010 = Tuple3_1(1, 0, 0);
|
|
258
|
+
}
|
|
259
|
+
else if (curPos == 1) {
|
|
260
|
+
_tmp010 = Tuple3_1(0, 1, 0);
|
|
261
|
+
}
|
|
262
|
+
else if (curPos == 2) {
|
|
263
|
+
_tmp010 = Tuple3_1(0, 0, 1);
|
|
264
|
+
}
|
|
265
|
+
_tmp008 = _tmp010;
|
|
266
|
+
}
|
|
267
|
+
else if (_tmp009 == 0) {
|
|
268
|
+
_tmp008 = Tuple3_1(0, 0, 0);
|
|
269
|
+
}
|
|
270
|
+
*output = _tmp008;
|
|
271
|
+
return 1;
|
|
272
|
+
}
|
|
273
|
+
static int node_dh(struct Tuple3_Int_Int_Int* anonymous69880537178160, int* output) {
|
|
274
|
+
int _tmp011;
|
|
275
|
+
if (1) {
|
|
276
|
+
int pvar0_dh = anonymous69880537178160->value.Tuple3.member0;
|
|
277
|
+
int pvar0_dm = anonymous69880537178160->value.Tuple3.member1;
|
|
278
|
+
int pvar0_ds = anonymous69880537178160->value.Tuple3.member2;
|
|
279
|
+
_tmp011 = pvar0_dh;
|
|
280
|
+
}
|
|
281
|
+
*output = _tmp011;
|
|
282
|
+
return 1;
|
|
283
|
+
}
|
|
284
|
+
static int node_dm(struct Tuple3_Int_Int_Int* anonymous69880537178160, int* output) {
|
|
285
|
+
int _tmp012;
|
|
286
|
+
if (1) {
|
|
287
|
+
int pvar1_dh = anonymous69880537178160->value.Tuple3.member0;
|
|
288
|
+
int pvar1_dm = anonymous69880537178160->value.Tuple3.member1;
|
|
289
|
+
int pvar1_ds = anonymous69880537178160->value.Tuple3.member2;
|
|
290
|
+
_tmp012 = pvar1_dm;
|
|
291
|
+
}
|
|
292
|
+
*output = _tmp012;
|
|
293
|
+
return 1;
|
|
294
|
+
}
|
|
295
|
+
static int node_ds(struct Tuple3_Int_Int_Int* anonymous69880537178160, int* output) {
|
|
296
|
+
int _tmp013;
|
|
297
|
+
if (1) {
|
|
298
|
+
int pvar2_dh = anonymous69880537178160->value.Tuple3.member0;
|
|
299
|
+
int pvar2_dm = anonymous69880537178160->value.Tuple3.member1;
|
|
300
|
+
int pvar2_ds = anonymous69880537178160->value.Tuple3.member2;
|
|
301
|
+
_tmp013 = pvar2_ds;
|
|
302
|
+
}
|
|
303
|
+
*output = _tmp013;
|
|
304
|
+
return 1;
|
|
305
|
+
}
|
|
306
|
+
static int node_maskHour(struct Tuple3_Bool_Bool_Bool* anonymous69880541228320, int* output) {
|
|
307
|
+
int _tmp014;
|
|
308
|
+
if (1) {
|
|
309
|
+
int pvar3_maskHour = anonymous69880541228320->value.Tuple3.member0;
|
|
310
|
+
int pvar3_maskMin = anonymous69880541228320->value.Tuple3.member1;
|
|
311
|
+
int pvar3_maskSec = anonymous69880541228320->value.Tuple3.member2;
|
|
312
|
+
_tmp014 = pvar3_maskHour;
|
|
313
|
+
}
|
|
314
|
+
*output = _tmp014;
|
|
315
|
+
return 1;
|
|
316
|
+
}
|
|
317
|
+
static int node_maskMin(struct Tuple3_Bool_Bool_Bool* anonymous69880541228320, int* output) {
|
|
318
|
+
int _tmp015;
|
|
319
|
+
if (1) {
|
|
320
|
+
int pvar4_maskHour = anonymous69880541228320->value.Tuple3.member0;
|
|
321
|
+
int pvar4_maskMin = anonymous69880541228320->value.Tuple3.member1;
|
|
322
|
+
int pvar4_maskSec = anonymous69880541228320->value.Tuple3.member2;
|
|
323
|
+
_tmp015 = pvar4_maskMin;
|
|
324
|
+
}
|
|
325
|
+
*output = _tmp015;
|
|
326
|
+
return 1;
|
|
327
|
+
}
|
|
328
|
+
static int node_maskSec(struct Tuple3_Bool_Bool_Bool* anonymous69880541228320, int* output) {
|
|
329
|
+
int _tmp016;
|
|
330
|
+
if (1) {
|
|
331
|
+
int pvar5_maskHour = anonymous69880541228320->value.Tuple3.member0;
|
|
332
|
+
int pvar5_maskMin = anonymous69880541228320->value.Tuple3.member1;
|
|
333
|
+
int pvar5_maskSec = anonymous69880541228320->value.Tuple3.member2;
|
|
334
|
+
_tmp016 = pvar5_maskSec;
|
|
335
|
+
}
|
|
336
|
+
*output = _tmp016;
|
|
337
|
+
return 1;
|
|
338
|
+
}
|
|
339
|
+
static int node_curTime(int pulse1s, struct Time* curTime_at_last, int dh, int dm, int ds, struct Time** output) {
|
|
340
|
+
struct Time* _tmp017;
|
|
341
|
+
if (pulse1s == 1) {
|
|
342
|
+
_tmp017 = roundingTime_0(proceedTime_0(curTime_at_last), dh, dm, ds);
|
|
343
|
+
}
|
|
344
|
+
else if (pulse1s == 0) {
|
|
345
|
+
_tmp017 = roundingTime_0(curTime_at_last, dh, dm, ds);
|
|
346
|
+
}
|
|
347
|
+
*output = _tmp017;
|
|
348
|
+
return 1;
|
|
349
|
+
}
|
|
350
|
+
static struct Time* init_curTime() {
|
|
351
|
+
return Time_0(0, 0, 0);
|
|
352
|
+
}
|
|
353
|
+
static int node_hour(struct Time* curTime, int* output) {
|
|
354
|
+
int _tmp018;
|
|
355
|
+
if (1) {
|
|
356
|
+
struct Time* pvar6_curTime = curTime;
|
|
357
|
+
int pvar6_hour = curTime->value.Time.member0;
|
|
358
|
+
int pvar6_min = curTime->value.Time.member1;
|
|
359
|
+
int pvar6_sec = curTime->value.Time.member2;
|
|
360
|
+
_tmp018 = pvar6_hour;
|
|
361
|
+
}
|
|
362
|
+
*output = _tmp018;
|
|
363
|
+
return 1;
|
|
364
|
+
}
|
|
365
|
+
static int init_hour() {
|
|
366
|
+
struct Time* _tmp020;
|
|
367
|
+
int _tmp019;
|
|
368
|
+
_tmp020 = Time_0(0, 0, 0);
|
|
369
|
+
if (1) {
|
|
370
|
+
struct Time* pvar7_curTime = _tmp020;
|
|
371
|
+
int pvar7_hour = _tmp020->value.Time.member0;
|
|
372
|
+
int pvar7_min = _tmp020->value.Time.member1;
|
|
373
|
+
int pvar7_sec = _tmp020->value.Time.member2;
|
|
374
|
+
_tmp019 = pvar7_hour;
|
|
375
|
+
}
|
|
376
|
+
return _tmp019;
|
|
377
|
+
}
|
|
378
|
+
static int node_min(struct Time* curTime, int* output) {
|
|
379
|
+
int _tmp021;
|
|
380
|
+
if (1) {
|
|
381
|
+
struct Time* pvar8_curTime = curTime;
|
|
382
|
+
int pvar8_hour = curTime->value.Time.member0;
|
|
383
|
+
int pvar8_min = curTime->value.Time.member1;
|
|
384
|
+
int pvar8_sec = curTime->value.Time.member2;
|
|
385
|
+
_tmp021 = pvar8_min;
|
|
386
|
+
}
|
|
387
|
+
*output = _tmp021;
|
|
388
|
+
return 1;
|
|
389
|
+
}
|
|
390
|
+
static int init_min() {
|
|
391
|
+
struct Time* _tmp023;
|
|
392
|
+
int _tmp022;
|
|
393
|
+
_tmp023 = Time_0(0, 0, 0);
|
|
394
|
+
if (1) {
|
|
395
|
+
struct Time* pvar9_curTime = _tmp023;
|
|
396
|
+
int pvar9_hour = _tmp023->value.Time.member0;
|
|
397
|
+
int pvar9_min = _tmp023->value.Time.member1;
|
|
398
|
+
int pvar9_sec = _tmp023->value.Time.member2;
|
|
399
|
+
_tmp022 = pvar9_min;
|
|
400
|
+
}
|
|
401
|
+
return _tmp022;
|
|
402
|
+
}
|
|
403
|
+
static int node_sec(struct Time* curTime, int* output) {
|
|
404
|
+
int _tmp024;
|
|
405
|
+
if (1) {
|
|
406
|
+
struct Time* pvar10_curTime = curTime;
|
|
407
|
+
int pvar10_hour = curTime->value.Time.member0;
|
|
408
|
+
int pvar10_min = curTime->value.Time.member1;
|
|
409
|
+
int pvar10_sec = curTime->value.Time.member2;
|
|
410
|
+
_tmp024 = pvar10_sec;
|
|
411
|
+
}
|
|
412
|
+
*output = _tmp024;
|
|
413
|
+
return 1;
|
|
414
|
+
}
|
|
415
|
+
static int init_sec() {
|
|
416
|
+
struct Time* _tmp026;
|
|
417
|
+
int _tmp025;
|
|
418
|
+
_tmp026 = Time_0(0, 0, 0);
|
|
419
|
+
if (1) {
|
|
420
|
+
struct Time* pvar11_curTime = _tmp026;
|
|
421
|
+
int pvar11_hour = _tmp026->value.Time.member0;
|
|
422
|
+
int pvar11_min = _tmp026->value.Time.member1;
|
|
423
|
+
int pvar11_sec = _tmp026->value.Time.member2;
|
|
424
|
+
_tmp025 = pvar11_sec;
|
|
425
|
+
}
|
|
426
|
+
return _tmp025;
|
|
427
|
+
}
|
|
428
|
+
static struct Time* roundingTime_0(struct Time* t, int dh, int dm, int ds) {
|
|
429
|
+
struct Time* _tmp027;
|
|
430
|
+
if (1) {
|
|
431
|
+
int pvar12_h = t->value.Time.member0;
|
|
432
|
+
int pvar12_m = t->value.Time.member1;
|
|
433
|
+
int pvar12_s = t->value.Time.member2;
|
|
434
|
+
_tmp027 = Time_0(_parcent_(_plus_(pvar12_h, dh), 24), _parcent_(_plus_(pvar12_m, dm), 60), _parcent_(_plus_(pvar12_s, ds), 60));
|
|
435
|
+
}
|
|
436
|
+
return _tmp027;
|
|
437
|
+
}
|
|
438
|
+
static struct Time* proceedTime_0(struct Time* t) {
|
|
439
|
+
struct Time* _tmp028;
|
|
440
|
+
if (1) {
|
|
441
|
+
int _tmp030;
|
|
442
|
+
int pvar13_h = t->value.Time.member0;
|
|
443
|
+
int pvar13_m = t->value.Time.member1;
|
|
444
|
+
int pvar13_s = t->value.Time.member2;
|
|
445
|
+
struct Time* _tmp029;
|
|
446
|
+
_tmp030 = _plus_(pvar13_s, 1);
|
|
447
|
+
if (1) {
|
|
448
|
+
int _tmp032;
|
|
449
|
+
int pvar14_newS = _tmp030;
|
|
450
|
+
struct Time* _tmp031;
|
|
451
|
+
_tmp032 = _plus_(pvar13_m, _slash_(pvar14_newS, 60));
|
|
452
|
+
if (1) {
|
|
453
|
+
int _tmp034;
|
|
454
|
+
int pvar15_newM = _tmp032;
|
|
455
|
+
struct Time* _tmp033;
|
|
456
|
+
_tmp034 = _plus_(pvar13_h, _slash_(pvar15_newM, 60));
|
|
457
|
+
if (1) {
|
|
458
|
+
int pvar16_newH = _tmp034;
|
|
459
|
+
_tmp033 = Time_0(_parcent_(pvar16_newH, 24), _parcent_(pvar15_newM, 60), _parcent_(pvar14_newS, 60));
|
|
460
|
+
}
|
|
461
|
+
_tmp031 = _tmp033;
|
|
462
|
+
}
|
|
463
|
+
_tmp029 = _tmp031;
|
|
464
|
+
}
|
|
465
|
+
_tmp028 = _tmp029;
|
|
466
|
+
}
|
|
467
|
+
return _tmp028;
|
|
468
|
+
}
|
|
469
|
+
static int editable_0(int m) {
|
|
470
|
+
int _tmp035;
|
|
471
|
+
if (m == 0) {
|
|
472
|
+
_tmp035 = 0;
|
|
473
|
+
}
|
|
474
|
+
else if (m == 1) {
|
|
475
|
+
_tmp035 = 1;
|
|
476
|
+
}
|
|
477
|
+
return _tmp035;
|
|
478
|
+
}
|
|
479
|
+
static int positiveEdge_0(int a, int b) {
|
|
480
|
+
return _anpersand_anpersand(_at__exclamation_(a), b);
|
|
481
|
+
}
|
|
482
|
+
static int nextMode_0(int m) {
|
|
483
|
+
int _tmp036;
|
|
484
|
+
if (m == 0) {
|
|
485
|
+
_tmp036 = 1;
|
|
486
|
+
}
|
|
487
|
+
else if (m == 1) {
|
|
488
|
+
_tmp036 = 0;
|
|
489
|
+
}
|
|
490
|
+
return _tmp036;
|
|
491
|
+
}
|
|
492
|
+
static int nextPos_0(int p) {
|
|
493
|
+
int _tmp037;
|
|
494
|
+
if (p == 0) {
|
|
495
|
+
_tmp037 = 1;
|
|
496
|
+
}
|
|
497
|
+
else if (p == 1) {
|
|
498
|
+
_tmp037 = 2;
|
|
499
|
+
}
|
|
500
|
+
else if (p == 2) {
|
|
501
|
+
_tmp037 = 0;
|
|
502
|
+
}
|
|
503
|
+
return _tmp037;
|
|
504
|
+
}
|
|
505
|
+
static void refreshMark() {
|
|
506
|
+
int i;
|
|
507
|
+
for (i = 0; i < size_Time; i++) {
|
|
508
|
+
if (memory_Time[i].mark < Counter) memory_Time[i].mark = 0;
|
|
509
|
+
else memory_Time[i].mark -= Counter - 1;
|
|
510
|
+
}
|
|
511
|
+
for (i = 0; i < size_Tuple3_Int_Int_Int; i++) {
|
|
512
|
+
if (memory_Tuple3_Int_Int_Int[i].mark < Counter) memory_Tuple3_Int_Int_Int[i].mark = 0;
|
|
513
|
+
else memory_Tuple3_Int_Int_Int[i].mark -= Counter - 1;
|
|
514
|
+
}
|
|
515
|
+
for (i = 0; i < size_Tuple3_Bool_Bool_Bool; i++) {
|
|
516
|
+
if (memory_Tuple3_Bool_Bool_Bool[i].mark < Counter) memory_Tuple3_Bool_Bool_Bool[i].mark = 0;
|
|
517
|
+
else memory_Tuple3_Bool_Bool_Bool[i].mark -= Counter - 1;
|
|
518
|
+
}
|
|
519
|
+
}
|
|
520
|
+
void ActivateLCDClock() {
|
|
521
|
+
int current_side = 0, last_side = 1;
|
|
522
|
+
node_memory_btnMode[last_side] = init_btnMode();
|
|
523
|
+
node_memory_btnNext[last_side] = init_btnNext();
|
|
524
|
+
node_memory_btnRotate[last_side] = init_btnRotate();
|
|
525
|
+
node_memory_counter[last_side] = init_counter();
|
|
526
|
+
node_memory_curMode[last_side] = init_curMode();
|
|
527
|
+
node_memory_curPos[last_side] = init_curPos();
|
|
528
|
+
node_memory_curTime[last_side] = init_curTime();
|
|
529
|
+
mark_Time(node_memory_curTime[last_side], 14);
|
|
530
|
+
node_memory_hour[last_side] = init_hour();
|
|
531
|
+
node_memory_min[last_side] = init_min();
|
|
532
|
+
node_memory_sec[last_side] = init_sec();
|
|
533
|
+
Counter = NodeSize + 1;
|
|
534
|
+
refreshMark();
|
|
535
|
+
while (1) {
|
|
536
|
+
Counter = 1;
|
|
537
|
+
Input(&node_memory_btnMode[current_side], &node_memory_btnNext[current_side], &node_memory_btnRotate[current_side], &node_memory_pulse100ms[current_side]);
|
|
538
|
+
node_counter(node_memory_pulse100ms[current_side], node_memory_counter[last_side], &node_memory_counter[current_side]);
|
|
539
|
+
Counter++;
|
|
540
|
+
node_curMode(node_memory_btnMode[last_side], node_memory_btnMode[current_side], node_memory_curMode[last_side], &node_memory_curMode[current_side]);
|
|
541
|
+
Counter++;
|
|
542
|
+
node_curPos(node_memory_btnNext[last_side], node_memory_btnNext[current_side], node_memory_curPos[last_side], &node_memory_curPos[current_side]);
|
|
543
|
+
Counter++;
|
|
544
|
+
node_pulse1s(node_memory_counter[current_side], node_memory_counter[last_side], &node_memory_pulse1s[current_side]);
|
|
545
|
+
Counter++;
|
|
546
|
+
node_flash(node_memory_counter[current_side], &node_memory_flash[current_side]);
|
|
547
|
+
Counter++;
|
|
548
|
+
node_anonymous69880537178160(node_memory_curMode[current_side], node_memory_btnRotate[last_side], node_memory_btnRotate[current_side], node_memory_curPos[current_side], &node_memory_anonymous69880537178160[current_side]);
|
|
549
|
+
mark_Tuple3_Int_Int_Int(node_memory_anonymous69880537178160[current_side], Counter + 4);
|
|
550
|
+
Counter++;
|
|
551
|
+
node_anonymous69880541228320(node_memory_curMode[current_side], node_memory_flash[current_side], node_memory_curPos[current_side], &node_memory_anonymous69880541228320[current_side]);
|
|
552
|
+
mark_Tuple3_Bool_Bool_Bool(node_memory_anonymous69880541228320[current_side], Counter + 6);
|
|
553
|
+
Counter++;
|
|
554
|
+
node_dh(node_memory_anonymous69880537178160[current_side], &node_memory_dh[current_side]);
|
|
555
|
+
Counter++;
|
|
556
|
+
node_dm(node_memory_anonymous69880537178160[current_side], &node_memory_dm[current_side]);
|
|
557
|
+
Counter++;
|
|
558
|
+
node_ds(node_memory_anonymous69880537178160[current_side], &node_memory_ds[current_side]);
|
|
559
|
+
Counter++;
|
|
560
|
+
node_maskHour(node_memory_anonymous69880541228320[current_side], &node_memory_maskHour[current_side]);
|
|
561
|
+
Counter++;
|
|
562
|
+
node_maskMin(node_memory_anonymous69880541228320[current_side], &node_memory_maskMin[current_side]);
|
|
563
|
+
Counter++;
|
|
564
|
+
node_maskSec(node_memory_anonymous69880541228320[current_side], &node_memory_maskSec[current_side]);
|
|
565
|
+
Counter++;
|
|
566
|
+
node_curTime(node_memory_pulse1s[current_side], node_memory_curTime[last_side], node_memory_dh[current_side], node_memory_dm[current_side], node_memory_ds[current_side], &node_memory_curTime[current_side]);
|
|
567
|
+
mark_Time(node_memory_curTime[current_side], Counter + 17);
|
|
568
|
+
Counter++;
|
|
569
|
+
node_hour(node_memory_curTime[current_side], &node_memory_hour[current_side]);
|
|
570
|
+
Counter++;
|
|
571
|
+
node_min(node_memory_curTime[current_side], &node_memory_min[current_side]);
|
|
572
|
+
Counter++;
|
|
573
|
+
node_sec(node_memory_curTime[current_side], &node_memory_sec[current_side]);
|
|
574
|
+
Counter++;
|
|
575
|
+
Output(&node_memory_hour[current_side], &node_memory_min[current_side], &node_memory_sec[current_side], &node_memory_maskHour[current_side], &node_memory_maskMin[current_side], &node_memory_maskSec[current_side]);
|
|
576
|
+
refreshMark();
|
|
577
|
+
current_side ^= 1;
|
|
578
|
+
last_side ^= 1;
|
|
579
|
+
}
|
|
580
|
+
}
|
|
@@ -0,0 +1,93 @@
|
|
|
1
|
+
module LCDClock
|
|
2
|
+
in
|
|
3
|
+
btnMode(False) : Bool, # Is mode-button pushed now?
|
|
4
|
+
btnNext(False) : Bool, # Is next-button pushed now?
|
|
5
|
+
btnRotate(False) : Bool, # Is rotate-button pushed now?
|
|
6
|
+
pulse100ms : Bool # input to be True only once per 100ms
|
|
7
|
+
out
|
|
8
|
+
hour, min, sec, # current time to display
|
|
9
|
+
maskHour, maskMin, maskSec # Is it now needed to display -- instead of two-digits?
|
|
10
|
+
use
|
|
11
|
+
Std
|
|
12
|
+
|
|
13
|
+
# Functions
|
|
14
|
+
# --------------------
|
|
15
|
+
|
|
16
|
+
type Mode = Normal | Edit
|
|
17
|
+
type EditPos = HourPos | MinPos | SecPos
|
|
18
|
+
type Time = Time(Int, Int, Int)
|
|
19
|
+
|
|
20
|
+
func nextMode(m) = m of Normal -> Edit, Edit -> Normal
|
|
21
|
+
|
|
22
|
+
func editable(m) = m of Normal -> False, Edit -> True
|
|
23
|
+
|
|
24
|
+
func nextPos(p) = p of:
|
|
25
|
+
HourPos -> MinPos
|
|
26
|
+
MinPos -> SecPos
|
|
27
|
+
SecPos -> HourPos
|
|
28
|
+
|
|
29
|
+
func positiveEdge(a, b) = !a && b
|
|
30
|
+
|
|
31
|
+
# proceed Time by 1sec
|
|
32
|
+
func proceedTime(t) = {
|
|
33
|
+
Time(h, m, s) = t
|
|
34
|
+
newS = s + 1
|
|
35
|
+
newM = m + (newS / 60)
|
|
36
|
+
newH = h + (newM / 60)
|
|
37
|
+
Time(newH % 24, newM % 60, newS % 60)
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
func roundingTime(t, dh, dm, ds) = {
|
|
41
|
+
Time(h, m, s) = t
|
|
42
|
+
Time((h + dh) % 24, (m + dm) % 60, (s + ds) % 60)
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
# Nodes
|
|
46
|
+
# --------------------
|
|
47
|
+
|
|
48
|
+
# mod-10 counter incremented by every 100ms
|
|
49
|
+
node init[0] counter : Int =
|
|
50
|
+
(if pulse100ms then counter@last + 1 else counter@last) % 10
|
|
51
|
+
|
|
52
|
+
# time-varying value to be True only once per 1sec
|
|
53
|
+
node pulse1s : Bool =
|
|
54
|
+
counter == 0 && counter@last != 0
|
|
55
|
+
|
|
56
|
+
# time-varying value switching True/False by every 500ms
|
|
57
|
+
node flash : Bool =
|
|
58
|
+
counter < 5
|
|
59
|
+
|
|
60
|
+
# time-varying value representing current time-set mode
|
|
61
|
+
node init[Normal] curMode : Mode =
|
|
62
|
+
if btnMode@last `positiveEdge` btnMode then curMode@last.nextMode else curMode@last
|
|
63
|
+
|
|
64
|
+
# time-varying value representing current editing-cursor-position
|
|
65
|
+
node init[HourPos] curPos : EditPos =
|
|
66
|
+
if btnNext@last `positiveEdge` btnNext then curPos@last.nextPos else curPos@last
|
|
67
|
+
|
|
68
|
+
# time-varying value representing diffs to add to current time.
|
|
69
|
+
node (dh, dm, ds) : (Int, Int, Int) =
|
|
70
|
+
if curMode.editable && (btnRotate@last `positiveEdge` btnRotate) then
|
|
71
|
+
curPos of:
|
|
72
|
+
HourPos -> (1, 0, 0)
|
|
73
|
+
MinPos -> (0, 1, 0)
|
|
74
|
+
SecPos -> (0, 0, 1)
|
|
75
|
+
else
|
|
76
|
+
(0, 0, 0)
|
|
77
|
+
|
|
78
|
+
# time-varying value representing current time
|
|
79
|
+
node init[Time(0, 0, 0)] Time(hour, min, sec) as curTime =
|
|
80
|
+
if pulse1s then
|
|
81
|
+
curTime@last.proceedTime.roundingTime(dh, dm, ds)
|
|
82
|
+
else
|
|
83
|
+
curTime@last.roundingTime(dh, dm, ds)
|
|
84
|
+
|
|
85
|
+
# time-varying value representing need of masking
|
|
86
|
+
node (maskHour, maskMin, maskSec) =
|
|
87
|
+
if curMode.editable && flash then
|
|
88
|
+
curPos of:
|
|
89
|
+
HourPos -> (True, False, False)
|
|
90
|
+
MinPos -> (False, True, False)
|
|
91
|
+
SecPos -> (False, False, True)
|
|
92
|
+
else
|
|
93
|
+
(False, False, False)
|
|
@@ -0,0 +1,42 @@
|
|
|
1
|
+
#include "LCDClock.h"
|
|
2
|
+
#include "mbed.h"
|
|
3
|
+
#include "C12832_lcd.h"
|
|
4
|
+
|
|
5
|
+
C12832_LCD lcd;
|
|
6
|
+
Ticker t;
|
|
7
|
+
DigitalIn center(p14), up(p15), right(p16);
|
|
8
|
+
int pulse100_flag = 0;
|
|
9
|
+
|
|
10
|
+
void timer_callback() {
|
|
11
|
+
pulse100_flag = 1;
|
|
12
|
+
}
|
|
13
|
+
|
|
14
|
+
void display(int n, int mask, char c) {
|
|
15
|
+
if (mask) {
|
|
16
|
+
lcd.printf("--%c", c);
|
|
17
|
+
} else {
|
|
18
|
+
lcd.printf("%02d%c", n, c);
|
|
19
|
+
}
|
|
20
|
+
}
|
|
21
|
+
|
|
22
|
+
void Input(int* btnMode, int* btnNext, int* btnRotate, int* pulse100ms) {
|
|
23
|
+
*btnMode = center.read();
|
|
24
|
+
*btnNext = right.read();
|
|
25
|
+
*btnRotate = up.read();
|
|
26
|
+
*pulse100ms = pulse100_flag;
|
|
27
|
+
pulse100_flag = 0;
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
void Output(int* hour, int* min, int* sec, int* maskHour, int* maskMin, int* maskSec) {
|
|
31
|
+
lcd.cls();
|
|
32
|
+
lcd.locate(45, 10);
|
|
33
|
+
display(*hour, *maskHour, ':');
|
|
34
|
+
display(*min, *maskMin, ':');
|
|
35
|
+
display(*sec, *maskSec, '\n');
|
|
36
|
+
wait(0.01);
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
int main() {
|
|
40
|
+
t.attach(&timer_callback, 0.1);
|
|
41
|
+
ActivateLCDClock();
|
|
42
|
+
}
|
|
Binary file
|
|
@@ -0,0 +1,24 @@
|
|
|
1
|
+
# LCD Clock
|
|
2
|
+
|
|
3
|
+
This is a program of the digital clock.
|
|
4
|
+
|
|
5
|
+
## Functions
|
|
6
|
+
* Center (push) button (of joystick) toggles on-off of time-set mode.
|
|
7
|
+
* Right button moves cursor of time-set targets (hour, minute and second).
|
|
8
|
+
* Up button raises time-set target's value (+1) if time-set mode is on.
|
|
9
|
+
|
|
10
|
+
## Target device
|
|
11
|
+
mbed LPC1768 with application board
|
|
12
|
+
|
|
13
|
+
## IO library
|
|
14
|
+
Following libraries are required.
|
|
15
|
+
* Basic IO library `mbed` (official)
|
|
16
|
+
* LCD's manipulation library `C12832_lcd` (third-party)
|
|
17
|
+
|
|
18
|
+
Both they are available from official library repository of *mbed.org*.
|
|
19
|
+
|
|
20
|
+
## Sample
|
|
21
|
+
|
|
22
|
+
|
|
23
|
+
|
|
24
|
+
* [Watch on YouTube](https://www.youtube.com/watch?v=Fah2iJAaouo)
|
|
@@ -0,0 +1,55 @@
|
|
|
1
|
+
digraph LCDClock {
|
|
2
|
+
pulse100ms [label = "pulse100ms : Bool", shape = "invhouse"];
|
|
3
|
+
counter [label = "counter : Int"];
|
|
4
|
+
pulse1s [label = "pulse1s : Bool"];
|
|
5
|
+
btnMode [label = "btnMode : Bool", shape = "invhouse"];
|
|
6
|
+
curMode [label = "curMode : Mode"];
|
|
7
|
+
btnRotate [label = "btnRotate : Bool", shape = "invhouse"];
|
|
8
|
+
btnNext [label = "btnNext : Bool", shape = "invhouse"];
|
|
9
|
+
curPos [label = "curPos : TPos"];
|
|
10
|
+
anonymous69998036981860 [label = "anonymous69998036981860 : Tuple3[Int, Int, Int]"];
|
|
11
|
+
dh [label = "dh : Int"];
|
|
12
|
+
dm [label = "dm : Int"];
|
|
13
|
+
ds [label = "ds : Int"];
|
|
14
|
+
curTime [label = "curTime : Time"];
|
|
15
|
+
hour [label = "hour : Int", style = filled, fillcolor = "#e4e4e4"];
|
|
16
|
+
min [label = "min : Int", style = filled, fillcolor = "#e4e4e4"];
|
|
17
|
+
sec [label = "sec : Int", style = filled, fillcolor = "#e4e4e4"];
|
|
18
|
+
flash [label = "flash : Bool"];
|
|
19
|
+
anonymous69998035646520 [label = "anonymous69998035646520 : Tuple3[Bool, Bool, Bool]"];
|
|
20
|
+
maskHour [label = "maskHour : Bool", style = filled, fillcolor = "#e4e4e4"];
|
|
21
|
+
maskMin [label = "maskMin : Bool", style = filled, fillcolor = "#e4e4e4"];
|
|
22
|
+
maskSec [label = "maskSec : Bool", style = filled, fillcolor = "#e4e4e4"];
|
|
23
|
+
curTime -> hour;
|
|
24
|
+
pulse1s -> curTime;
|
|
25
|
+
counter -> pulse1s;
|
|
26
|
+
pulse100ms -> counter;
|
|
27
|
+
counter -> counter [style = dashed];
|
|
28
|
+
counter -> pulse1s [style = dashed];
|
|
29
|
+
curTime -> curTime [style = dashed];
|
|
30
|
+
dh -> curTime;
|
|
31
|
+
anonymous69998036981860 -> dh;
|
|
32
|
+
curMode -> anonymous69998036981860;
|
|
33
|
+
btnMode -> curMode [style = dashed];
|
|
34
|
+
btnMode -> curMode;
|
|
35
|
+
curMode -> curMode [style = dashed];
|
|
36
|
+
btnRotate -> anonymous69998036981860 [style = dashed];
|
|
37
|
+
btnRotate -> anonymous69998036981860;
|
|
38
|
+
curPos -> anonymous69998036981860;
|
|
39
|
+
btnNext -> curPos [style = dashed];
|
|
40
|
+
btnNext -> curPos;
|
|
41
|
+
curPos -> curPos [style = dashed];
|
|
42
|
+
dm -> curTime;
|
|
43
|
+
anonymous69998036981860 -> dm;
|
|
44
|
+
ds -> curTime;
|
|
45
|
+
anonymous69998036981860 -> ds;
|
|
46
|
+
curTime -> min;
|
|
47
|
+
curTime -> sec;
|
|
48
|
+
anonymous69998035646520 -> maskHour;
|
|
49
|
+
curMode -> anonymous69998035646520;
|
|
50
|
+
flash -> anonymous69998035646520;
|
|
51
|
+
counter -> flash;
|
|
52
|
+
curPos -> anonymous69998035646520;
|
|
53
|
+
anonymous69998035646520 -> maskMin;
|
|
54
|
+
anonymous69998035646520 -> maskSec;
|
|
55
|
+
}
|
|
Binary file
|
data/lib/emfrp/parser/misc.rb
CHANGED
data/lib/emfrp/version.rb
CHANGED
|
@@ -0,0 +1,90 @@
|
|
|
1
|
+
module LCDClock
|
|
2
|
+
in
|
|
3
|
+
btnMode(False) : Bool, # Is mode-button pushed now?
|
|
4
|
+
btnNext(False) : Bool, # Is next-button pushed now?
|
|
5
|
+
btnRotate(False) : Bool, # Is rotate-button pushed now?
|
|
6
|
+
pulse100ms : Bool # input to be True only once per 100ms
|
|
7
|
+
out
|
|
8
|
+
hour, min, sec, # current time to display
|
|
9
|
+
maskHour, maskMin, maskSec # Is it now needed to display -- instead of two-digits?
|
|
10
|
+
use
|
|
11
|
+
Std
|
|
12
|
+
|
|
13
|
+
# Functions
|
|
14
|
+
# --------------------
|
|
15
|
+
|
|
16
|
+
type Mode = Normal | Edit
|
|
17
|
+
type TPos = HPos | MPos | SPos
|
|
18
|
+
type Time = Time(Int, Int, Int)
|
|
19
|
+
|
|
20
|
+
func nextMode(m) = m of Normal -> Edit, Edit -> Normal
|
|
21
|
+
|
|
22
|
+
func editable(m) = m of Normal -> False, Edit -> True
|
|
23
|
+
|
|
24
|
+
func nextPos(p) = p of HPos -> MPos, MPos -> SPos, SPos -> HPos
|
|
25
|
+
|
|
26
|
+
func positiveEdge(a, b) = !a && b
|
|
27
|
+
|
|
28
|
+
# proceed Time by 1sec
|
|
29
|
+
func proceedTime(t) = {
|
|
30
|
+
Time(h, m, s) = t
|
|
31
|
+
newS = s + 1
|
|
32
|
+
newM = m + (newS / 60)
|
|
33
|
+
newH = h + (newM / 60)
|
|
34
|
+
Time(newH % 24, newM % 60, newS % 60)
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
func roundingTime(t, dh, dm, ds) = {
|
|
38
|
+
Time(h, m, s) = t
|
|
39
|
+
Time((h + dh) % 24, (m + dm) % 60, (s + ds) % 60)
|
|
40
|
+
}
|
|
41
|
+
|
|
42
|
+
# Nodes
|
|
43
|
+
# --------------------
|
|
44
|
+
|
|
45
|
+
# mod-10 counter incremented by every 100ms
|
|
46
|
+
node init[0] counter : Int =
|
|
47
|
+
(if pulse100ms then counter@last + 1 else counter@last) % 10
|
|
48
|
+
|
|
49
|
+
# time-varying value to be True only once per 1sec
|
|
50
|
+
node pulse1s : Bool =
|
|
51
|
+
counter == 0 && counter@last != 0
|
|
52
|
+
|
|
53
|
+
# time-varying value switching True/False by every 500ms
|
|
54
|
+
node flash : Bool =
|
|
55
|
+
counter < 5
|
|
56
|
+
|
|
57
|
+
# time-varying value representing current time-set mode
|
|
58
|
+
node init[Normal] curMode : Mode =
|
|
59
|
+
if btnMode@last `positiveEdge` btnMode then curMode@last.nextMode else curMode@last
|
|
60
|
+
|
|
61
|
+
# time-varying value representing current editing-cursor-position
|
|
62
|
+
node init[HPos] curPos : TPos =
|
|
63
|
+
if btnNext@last `positiveEdge` btnNext then curPos@last.nextPos else curPos@last
|
|
64
|
+
|
|
65
|
+
# time-varying value representing diffs to add to current time.
|
|
66
|
+
node (dh, dm, ds) : (Int, Int, Int) =
|
|
67
|
+
if curMode.editable && (btnRotate@last `positiveEdge` btnRotate) then
|
|
68
|
+
curPos of:
|
|
69
|
+
HPos -> (1, 0, 0)
|
|
70
|
+
MPos -> (0, 1, 0)
|
|
71
|
+
SPos -> (0, 0, 1)
|
|
72
|
+
else
|
|
73
|
+
(0, 0, 0)
|
|
74
|
+
|
|
75
|
+
# time-varying value representing current time
|
|
76
|
+
node init[Time(0, 0, 0)] Time(hour, min, sec) as curTime =
|
|
77
|
+
if pulse1s then
|
|
78
|
+
curTime@last.proceedTime.roundingTime(dh, dm, ds)
|
|
79
|
+
else
|
|
80
|
+
curTime@last.roundingTime(dh, dm, ds)
|
|
81
|
+
|
|
82
|
+
# time-varying value representing need of masking
|
|
83
|
+
node (maskHour, maskMin, maskSec) =
|
|
84
|
+
if curMode.editable && flash then
|
|
85
|
+
curPos of:
|
|
86
|
+
HPos -> (True, False, False)
|
|
87
|
+
MPos -> (False, True, False)
|
|
88
|
+
SPos -> (False, False, True)
|
|
89
|
+
else
|
|
90
|
+
(False, False, False)
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
#include "LCDClock.h"
|
|
2
|
+
#include <stdio.h>
|
|
3
|
+
#include <stdlib.h>
|
|
4
|
+
|
|
5
|
+
void display(int n, int mask, char c) {
|
|
6
|
+
if (mask) {
|
|
7
|
+
printf("--%c", c);
|
|
8
|
+
} else {
|
|
9
|
+
printf("%02d%c", n, c);
|
|
10
|
+
}
|
|
11
|
+
}
|
|
12
|
+
|
|
13
|
+
void Input(int* btnMode, int* btnNext, int* btnRotate, int* pulse100ms) {
|
|
14
|
+
if (scanf("%d %d %d %d", btnMode, btnNext, btnRotate, pulse100ms) == EOF) {
|
|
15
|
+
exit(0);
|
|
16
|
+
}
|
|
17
|
+
}
|
|
18
|
+
void Output(int* hour, int* min, int* sec, int* maskHour, int* maskMin, int* maskSec) {
|
|
19
|
+
display(*hour, *maskHour, ':');
|
|
20
|
+
display(*min, *maskMin, ':');
|
|
21
|
+
display(*sec, *maskSec, '\n');
|
|
22
|
+
}
|
|
23
|
+
|
|
24
|
+
int main() {
|
|
25
|
+
ActivateLCDClock();
|
|
26
|
+
}
|
|
@@ -0,0 +1,60 @@
|
|
|
1
|
+
00:00:00
|
|
2
|
+
00:00:00
|
|
3
|
+
00:00:00
|
|
4
|
+
00:00:00
|
|
5
|
+
00:00:00
|
|
6
|
+
00:00:00
|
|
7
|
+
--:00:00
|
|
8
|
+
--:00:00
|
|
9
|
+
--:00:00
|
|
10
|
+
00:00:00
|
|
11
|
+
00:00:00
|
|
12
|
+
00:00:00
|
|
13
|
+
00:00:00
|
|
14
|
+
00:00:00
|
|
15
|
+
--:00:01
|
|
16
|
+
--:00:01
|
|
17
|
+
--:00:01
|
|
18
|
+
--:00:01
|
|
19
|
+
--:00:01
|
|
20
|
+
00:00:01
|
|
21
|
+
00:00:01
|
|
22
|
+
00:00:01
|
|
23
|
+
00:00:01
|
|
24
|
+
00:00:01
|
|
25
|
+
--:00:02
|
|
26
|
+
--:00:02
|
|
27
|
+
--:00:02
|
|
28
|
+
--:00:02
|
|
29
|
+
--:00:02
|
|
30
|
+
01:00:02
|
|
31
|
+
01:00:02
|
|
32
|
+
01:00:02
|
|
33
|
+
01:00:02
|
|
34
|
+
01:00:02
|
|
35
|
+
01:--:03
|
|
36
|
+
01:--:03
|
|
37
|
+
01:--:03
|
|
38
|
+
01:--:03
|
|
39
|
+
01:--:03
|
|
40
|
+
01:00:03
|
|
41
|
+
01:00:03
|
|
42
|
+
01:00:03
|
|
43
|
+
01:00:03
|
|
44
|
+
01:00:03
|
|
45
|
+
01:00:--
|
|
46
|
+
01:00:--
|
|
47
|
+
01:00:--
|
|
48
|
+
01:00:--
|
|
49
|
+
01:00:--
|
|
50
|
+
01:00:04
|
|
51
|
+
01:00:04
|
|
52
|
+
01:00:04
|
|
53
|
+
01:00:04
|
|
54
|
+
01:00:04
|
|
55
|
+
--:00:05
|
|
56
|
+
--:00:05
|
|
57
|
+
--:00:05
|
|
58
|
+
--:00:05
|
|
59
|
+
--:00:05
|
|
60
|
+
01:00:05
|
|
@@ -0,0 +1,60 @@
|
|
|
1
|
+
00:00:00
|
|
2
|
+
00:00:00
|
|
3
|
+
00:00:00
|
|
4
|
+
00:00:00
|
|
5
|
+
00:00:00
|
|
6
|
+
00:00:00
|
|
7
|
+
--:00:00
|
|
8
|
+
--:00:00
|
|
9
|
+
--:00:00
|
|
10
|
+
00:00:00
|
|
11
|
+
00:00:00
|
|
12
|
+
00:00:00
|
|
13
|
+
00:00:00
|
|
14
|
+
00:00:00
|
|
15
|
+
--:00:01
|
|
16
|
+
--:00:01
|
|
17
|
+
--:00:01
|
|
18
|
+
--:00:01
|
|
19
|
+
--:00:01
|
|
20
|
+
00:00:01
|
|
21
|
+
00:00:01
|
|
22
|
+
00:00:01
|
|
23
|
+
00:00:01
|
|
24
|
+
00:00:01
|
|
25
|
+
--:00:02
|
|
26
|
+
--:00:02
|
|
27
|
+
--:00:02
|
|
28
|
+
--:00:02
|
|
29
|
+
--:00:02
|
|
30
|
+
01:00:02
|
|
31
|
+
01:00:02
|
|
32
|
+
01:00:02
|
|
33
|
+
01:00:02
|
|
34
|
+
01:00:02
|
|
35
|
+
01:--:03
|
|
36
|
+
01:--:03
|
|
37
|
+
01:--:03
|
|
38
|
+
01:--:03
|
|
39
|
+
01:--:03
|
|
40
|
+
01:00:03
|
|
41
|
+
01:00:03
|
|
42
|
+
01:00:03
|
|
43
|
+
01:00:03
|
|
44
|
+
01:00:03
|
|
45
|
+
01:00:--
|
|
46
|
+
01:00:--
|
|
47
|
+
01:00:--
|
|
48
|
+
01:00:--
|
|
49
|
+
01:00:--
|
|
50
|
+
01:00:04
|
|
51
|
+
01:00:04
|
|
52
|
+
01:00:04
|
|
53
|
+
01:00:04
|
|
54
|
+
01:00:04
|
|
55
|
+
--:00:05
|
|
56
|
+
--:00:05
|
|
57
|
+
--:00:05
|
|
58
|
+
--:00:05
|
|
59
|
+
--:00:05
|
|
60
|
+
01:00:05
|
|
@@ -0,0 +1,60 @@
|
|
|
1
|
+
0 0 0 0
|
|
2
|
+
0 0 0 0
|
|
3
|
+
0 0 0 0
|
|
4
|
+
0 0 0 0
|
|
5
|
+
0 0 0 0
|
|
6
|
+
0 0 0 1
|
|
7
|
+
1 0 0 1
|
|
8
|
+
0 0 0 1
|
|
9
|
+
0 0 0 1
|
|
10
|
+
0 0 0 1
|
|
11
|
+
0 0 0 1
|
|
12
|
+
0 0 0 1
|
|
13
|
+
0 0 0 1
|
|
14
|
+
0 0 0 1
|
|
15
|
+
0 0 0 1
|
|
16
|
+
0 0 0 1
|
|
17
|
+
0 0 0 1
|
|
18
|
+
0 0 0 1
|
|
19
|
+
0 0 0 1
|
|
20
|
+
0 0 0 1
|
|
21
|
+
0 0 0 1
|
|
22
|
+
0 0 0 1
|
|
23
|
+
0 0 0 1
|
|
24
|
+
0 0 0 1
|
|
25
|
+
0 0 1 1
|
|
26
|
+
0 0 0 1
|
|
27
|
+
0 0 0 1
|
|
28
|
+
0 0 0 1
|
|
29
|
+
0 0 0 1
|
|
30
|
+
0 0 0 1
|
|
31
|
+
0 0 0 1
|
|
32
|
+
0 0 0 1
|
|
33
|
+
0 1 0 1
|
|
34
|
+
0 0 0 1
|
|
35
|
+
0 0 0 1
|
|
36
|
+
0 0 0 1
|
|
37
|
+
0 0 0 1
|
|
38
|
+
0 0 0 1
|
|
39
|
+
0 0 0 1
|
|
40
|
+
0 0 0 1
|
|
41
|
+
0 0 0 1
|
|
42
|
+
0 0 0 1
|
|
43
|
+
0 0 0 1
|
|
44
|
+
0 1 0 1
|
|
45
|
+
0 0 0 1
|
|
46
|
+
0 0 0 1
|
|
47
|
+
0 0 0 1
|
|
48
|
+
0 0 0 1
|
|
49
|
+
0 0 0 1
|
|
50
|
+
0 0 0 1
|
|
51
|
+
0 0 0 1
|
|
52
|
+
0 1 0 1
|
|
53
|
+
0 0 0 1
|
|
54
|
+
0 0 0 1
|
|
55
|
+
0 0 0 1
|
|
56
|
+
0 0 0 1
|
|
57
|
+
0 0 0 1
|
|
58
|
+
0 0 0 1
|
|
59
|
+
0 0 0 1
|
|
60
|
+
0 0 0 1
|
metadata
CHANGED
|
@@ -1,14 +1,14 @@
|
|
|
1
1
|
--- !ruby/object:Gem::Specification
|
|
2
2
|
name: emfrp
|
|
3
3
|
version: !ruby/object:Gem::Version
|
|
4
|
-
version: 0.1.
|
|
4
|
+
version: 0.1.2
|
|
5
5
|
platform: ruby
|
|
6
6
|
authors:
|
|
7
7
|
- Kensuke Sawada
|
|
8
8
|
autorequire:
|
|
9
9
|
bindir: bin
|
|
10
10
|
cert_chain: []
|
|
11
|
-
date: 2016-01-
|
|
11
|
+
date: 2016-01-19 00:00:00.000000000 Z
|
|
12
12
|
dependencies:
|
|
13
13
|
- !ruby/object:Gem::Dependency
|
|
14
14
|
name: colorize
|
|
@@ -83,6 +83,14 @@ files:
|
|
|
83
83
|
- bin/emfrp
|
|
84
84
|
- bin/emfrpi
|
|
85
85
|
- emfrp.gemspec
|
|
86
|
+
- examples/LCDClock/LCDClock.c
|
|
87
|
+
- examples/LCDClock/LCDClock.h
|
|
88
|
+
- examples/LCDClock/LCDClock.mfrp
|
|
89
|
+
- examples/LCDClock/LCDClockMain.c
|
|
90
|
+
- examples/LCDClock/LCDClock_LPC1768.bin
|
|
91
|
+
- examples/LCDClock/README.md
|
|
92
|
+
- examples/LCDClock/graph.dot
|
|
93
|
+
- examples/LCDClock/graph.png
|
|
86
94
|
- examples/LCDPositioner/LCDPositioner.c
|
|
87
95
|
- examples/LCDPositioner/LCDPositioner.h
|
|
88
96
|
- examples/LCDPositioner/LCDPositioner.mfrp
|
|
@@ -137,6 +145,12 @@ files:
|
|
|
137
145
|
- tests/compiler/ComplexDataType/expected_out.txt
|
|
138
146
|
- tests/compiler/ComplexDataType/graph.png
|
|
139
147
|
- tests/compiler/ComplexDataType/in.txt
|
|
148
|
+
- tests/compiler/LCDClock/LCDClock.mfrp
|
|
149
|
+
- tests/compiler/LCDClock/LCDClockMain.c
|
|
150
|
+
- tests/compiler/LCDClock/Rakefile
|
|
151
|
+
- tests/compiler/LCDClock/actual_out.txt
|
|
152
|
+
- tests/compiler/LCDClock/expected_out.txt
|
|
153
|
+
- tests/compiler/LCDClock/in.txt
|
|
140
154
|
- tests/compiler/LCDPositioner/LCDPositioner.mfrp
|
|
141
155
|
- tests/compiler/LCDPositioner/LCDPositionerMain.c
|
|
142
156
|
- tests/compiler/LCDPositioner/Rakefile
|