EsploraTable

Copy
1/*
2
3  Esplora Table
4
5  Acts like a keyboard that prints sensor
6
7  data in a table-like text, row by row.
8
9  At startup, it does nothing. It waits for you to open a
10
11  spreadsheet (e.g. Google Drive spreadsheet) so it can write
12
13  data. By pressing Switch 1, it starts printing the table
14
15  headers and the first row of data. It waits a bit, then it
16
17  will print another row, and so on.
18
19  The amount of time between each row is determined by the slider.
20
21  If put to full left, the sketch will wait 10 seconds; at
22
23  full right position, it will wait 5 minutes. An intermediate
24
25  position will make the sketch wait for some time in-between.
26
27  Clicking the Switch 1 at any time will stop the logging.
28
29  The color LED shows what the sketch is doing:
30
31  blue  = idle, waiting for you to press Switch 1 to start logging
32
33  green = active; will print soon
34
35  red   = printing data to the PC
36
37  Created on 22 november 2012
38
39  By Enrico Gueli <enrico.gueli@gmail.com>
40
41  modified 24 Nov 2012
42
43  by Tom Igoe
44
45*/
46
47#include <Esplora.h>
48
49/*
50
51 * this variable tells if the data-logging is currently active.
52
53 */
54
55bool active = false;
56
57/*
58
59 * this variable holds the time in the future when the sketch
60
61 * will "sample" the data (sampling is the act of reading some
62
63 * input at a known time). This variable is checked continuously
64
65 * against millis() to know when it's time to sample.
66
67 */
68unsigned long nextSampleAt = 0;
69
70/*
71
72 * This variable just holds the millis() value at the time the
73
74 * logging was activated. This is needed to enter the correct
75
76 * value in the "Time" column in the printed table.
77
78 */
79unsigned long startedAt = 0;
80
81/*
82
83 * when the "active" variable is set to true, the same is done
84
85 * with this variable. This is needed because the code that does
86
87 * the "just-after-activation" stuff is run some time later than
88
89 * the code that says "be active now".
90
91 */
92
93bool justActivated = false;
94
95/*
96
97 * this variable holds the last sensed status of the switch press
98
99 * button. If the code sees a difference between the value of
100
101 * this variable and the current status of the switch, it means
102
103 * that the button was either pressed or released.
104
105 */
106
107bool lastStartBtn = HIGH;
108
109/*
110
111 * Initialization code. The virtual USB keyboard must be
112
113 * initialized; the Serial class is needed just for debugging.
114
115 */
116void setup() {
117
118  Keyboard.begin();
119
120  Serial.begin(9600);
121}
122
123/*
124
125 * This code is run continuously.
126
127 */
128void loop() {
129
130  /*
131
132   * note: we don't use Arduino's delay() here, because we can't
133
134   * normally do anything while delaying. Our own version lets us
135
136   * check for button presses often enough to not miss any event.
137
138   */
139
140  activeDelay(50);
141
142  /*
143
144   * the justActivated variable may be set to true in the
145
146   * checkSwitchPress() function. Here we check its status to
147
148   * print the table headers and configure what's needed to.
149
150   */
151
152  if (justActivated == true) {
153
154    justActivated = false; // do this just once
155
156    printHeaders();
157
158    // do next sampling ASAP
159
160    nextSampleAt = startedAt = millis();
161
162  }
163
164  if (active == true) {
165
166    if (nextSampleAt < millis()) {
167
168      // it's time to sample!
169
170      int slider = Esplora.readSlider();
171
172      // the row below maps the slider position to a range between
173
174      // 10 and 290 seconds.
175
176      int sampleInterval = map(slider, 0, 1023, 10, 290);
177
178      nextSampleAt = millis() + sampleInterval * 1000;
179
180      logAndPrint();
181
182    }
183
184    // let the RGB led blink green once per second, for 200ms.
185
186    unsigned int ms = millis() % 1000;
187
188    if (ms < 200) {
189
190      Esplora.writeGreen(50);
191
192    } else {
193
194      Esplora.writeGreen(0);
195
196    }
197
198    Esplora.writeBlue(0);
199
200  } else
201
202    // while not active, keep a reassuring blue color coming
203
204    // from the Esplora...
205
206  {
207
208    Esplora.writeBlue(20);
209
210  }
211
212}
213
214/*
215
216 * Print the table headers.
217
218 */
219void printHeaders() {
220
221  Keyboard.print("Time");
222
223  Keyboard.write(KEY_TAB);
224
225  activeDelay(300); // Some spreadsheets are slow, e.g. Google
226
227  // Drive that wants to save every edit.
228
229  Keyboard.print("Accel X");
230
231  Keyboard.write(KEY_TAB);
232
233  activeDelay(300);
234
235  Keyboard.print("Accel Y");
236
237  Keyboard.write(KEY_TAB);
238
239  activeDelay(300);
240
241  Keyboard.print("Accel Z");
242
243  Keyboard.println();
244
245  activeDelay(300);
246}
247
248void logAndPrint() {
249
250  // do all the samplings at once, because keystrokes have delays
251
252  unsigned long timeSecs = (millis() - startedAt) / 1000;
253
254  int xAxis = Esplora.readAccelerometer(X_AXIS);
255
256  int yAxis = Esplora.readAccelerometer(Y_AXIS);
257
258  int zAxis = Esplora.readAccelerometer(Z_AXIS);
259
260  Esplora.writeRed(100);
261
262  Keyboard.print(timeSecs);
263
264  Keyboard.write(KEY_TAB);
265
266  activeDelay(300);
267
268  Keyboard.print(xAxis);
269
270  Keyboard.write(KEY_TAB);
271
272  activeDelay(300);
273
274  Keyboard.print(yAxis);
275
276  Keyboard.write(KEY_TAB);
277
278  activeDelay(300);
279
280  Keyboard.print(zAxis);
281
282  Keyboard.println();
283
284  activeDelay(300);
285
286  Keyboard.write(KEY_HOME);
287
288  Esplora.writeRed(0);
289}
290
291/**
292
293 * Similar to delay(), but allows the program to do something else
294
295 * in the meanwhile. In particular, it calls checkSwitchPress().
296
297 * Note 1: it may wait longer than the specified amount, not less;
298
299 * Note 2: beware of data synchronization issues, e.g. if the
300
301 * activeDelay() function alters some variables used by the
302
303 * caller of this function.
304
305 */
306void activeDelay(unsigned long amount) {
307
308  unsigned long at = millis() + amount;
309
310  while (millis() < at) {
311
312    checkSwitchPress();
313
314  }
315}
316
317/*
318
319 * This function reads the status of the switch; if it sees that
320
321 * it was pressed, toggles the status of the "active" variable.
322
323 * If it's set to true, also the justActivated variable is set to
324
325 * true, so the loop() function above can do the right things.
326
327 * This function should be called as often as possible and do as
328
329 * little as possible, because it can be called while another
330
331 * function is running.
332
333 */
334void checkSwitchPress() {
335
336  bool startBtn = Esplora.readButton(SWITCH_DOWN);
337
338  if (startBtn != lastStartBtn) {
339
340    if (startBtn == HIGH) { // button released
341
342      active = !active;
343
344      if (active) {
345
346        justActivated = true;
347
348      }
349
350    }
351
352    lastStartBtn = startBtn;
353
354  }
355}