-
Notifications
You must be signed in to change notification settings - Fork 0
/
alarmClock.c
599 lines (547 loc) · 15.9 KB
/
alarmClock.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
//*****************************************************************************
//
// David Rosales
// EID: dar542
// Lab Project 3
//
// A simple program to use as an alarm clock. To start the clock, you must
// first initialize the time by holding down the left directional pad button.
// While holding the button, a display lets the user know they are in the
// set clock mode. The use can press up or down on the directional pad to
// increase or decrease the time. There is a switch from a.m. to p.m. when
// you cycle through twelve hours.
//
// To set the alarm, you do all of the above but instead hold down the right
// directional pad button instead of the left.
//
// When the time reaches the
// time set for the alarm, an LED is lit on the board and the alarm noise
// sounds. The LED and sound are turned off by pressing the Select button
// on the device.
//
// A snooze mode is also implemented where instead of just pressing the
// select button to turn off the LED, you can hold it for ~1 second. This
// turns off the LED and sound and increases the alarm time by 5 minutes.
//
//*****************************************************************************
#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "driverlib/debug.h"
#include "driverlib/gpio.h"
#include "driverlib/pwm.h"
#include "driverlib/sysctl.h"
#include "drivers/rit128x96x4.h"
#include "inc/lm3s8962.h"
#include "inc/hw_gpio.h"
#include "utils/ustdlib.h"
#include "utils/ustdlib.c"
#include "inc/hw_ints.h"
#include "inc/hw_nvic.h"
#include "driverlib/interrupt.h"
#include "driverlib/systick.h"
//*****************************************************************************
//
// Initialize global variables.
//
//*****************************************************************************
volatile unsigned long t = 0;
volatile unsigned long x = 0;
volatile unsigned long y = 0;
volatile int alarmSet = 0;
volatile int toggleVal = 0;
volatile int blink = 0;
volatile int start = 0;
volatile int ampm = 0;
volatile int m1 = 0;
volatile int m2 = 0;
volatile int h1 = 2;
volatile int h2 = 1;
volatile int aampm = 0;
volatile int am1 = 0;
volatile int am2 = 0;
volatile int ah1 = 2;
volatile int ah2 = 1;
//*****************************************************************************
//
// The error routine that is called if the driver library encounters an error.
//
//*****************************************************************************
#ifdef DEBUG
void
__error__(char *pcFilename, unsigned long ulLine)
{
}
#endif
//*****************************************************************************
//
// Helper Functions
//
//*****************************************************************************
static void DisplayTime(void){
// Method for displaying the time based on the counters
static char pcTime[10];
if (ampm==0){
usprintf(pcTime, "%d%d:%d%d AM", h2, h1, m2, m1);
}
else {
usprintf(pcTime, "%d%d:%d%d PM", h2, h1, m2, m1);
}
RIT128x96x4StringDraw(pcTime, 40, 40, 15);
if (alarmSet){
RIT128x96x4StringDraw("Alarm ON", 40, 80, 15);
}
}
static void DisplayTimeA(void){
// Method for displaying the alarm based on the counters
static char pcTime[10];
if (aampm==0){
usprintf(pcTime, "%d%d:%d%d AM", ah2, ah1, am2, am1);
}
else {
usprintf(pcTime, "%d%d:%d%d PM", ah2, ah1, am2, am1);
}
RIT128x96x4StringDraw(pcTime, 40, 40, 15);
if (alarmSet){
RIT128x96x4StringDraw("Alarm ON", 40, 80, 15);
}
}
static void IncrementTime(void){
// Method for handling the increments of the time appropriately
m1++;
if (m1>9){
// We increment the 2nd minute place if minute place 1 is 10
m1 = 0;
m2++;
}
if (m2>5){
// We increment the 1st hour place if minute place 2 is 6
m2 = 0;
h1++;
if (h1==2 && h2==1){
// We switched between am and pm here so we need to handle
if (ampm){
ampm = 0;
}
else {
ampm = 1;
}
}
}
if (h1>9){
// We increment the 2nd hour place if hour place 1 is 10
h1 = 0;
h2++;
}
if (h2>0){
if(h1>2){
// If the 2nd hour place is 1, hour place 1 can only increase to 2
// until we have to reset
h1 = 1;
h2 = 0;
}
}
}
static void IncrementTimeA(void){
// Method for handling increments of the alarm appropriately
am1++;
if (am1>9){
// We increment the 2nd minute place if minute place 1 is 10
am1 = 0;
am2++;
}
if (am2>5){
// We increment the 1st hour place if minute place 2 is 6
am2 = 0;
ah1++;
if (ah1==2 && ah2==1){
// We switched between am and pm here so we need to handle
if (aampm){
aampm = 0;
}
else {
aampm = 1;
}
}
}
if (ah1>9){
// We increment the 2nd hour place if hour place 1 is 10
ah1 = 0;
ah2++;
}
if (ah2>0){
if(ah1>2){
// If the 2nd hour place is 1, hour place 1 can only increase to 2
// until we have to reset
ah1 = 1;
ah2 = 0;
}
}
}
static void DecrementTime(void){
// Method for handling decrements of the time appropriately
// If minute place 1 > 0 we can just decrement
if (m1>0){
m1--;
}
else {
// Minute place 1 is 0 so it decreases to 9
m1 = 9;
if (m2==0){
// Minute place 2 is 0 so it decreases to 5
m2 = 5;
if (h1==0){
// If hour place 1 is 0, then it is 10:XX and we set to 09:XX
h1 = 9;
h2 = 0;
}
else if (h1==1){
// Hour place 1 can be 1 in two instances 11:00 and 01:00 so we
// handle this here
if (h2>0){
// If hour place 2 is not 0, then it is 11:00 and we can
// just decrement
h1--;
}
else {
// It is 01:00 so we set to 12:59
h1 = 2;
h2 = 1;
}
}
else {
// We can just decrement
h1--;
if (h1==1 && h2==1){
// We switched between am and pm here so we need to handle
if (ampm){
ampm = 0;
}
else {
ampm = 1;
}
}
}
}
else {
// We can just decrement
m2--;
}
}
}
static void DecrementTimeA(void){
// Method for handling decrements of the alarm appropriately
// If minute place 1 > 0 we can just decrement
if (am1>0){
am1--;
}
else {
// Minute place 1 is 0 so it decreases to 9
am1 = 9;
if (am2==0){
// Minute place 2 is 0 so it decreases to 5
am2 = 5;
if (ah1==0){
// If hour place 1 is 0, then it is 10:XX and we set to 09:XX
ah1 = 9;
ah2 = 0;
}
else if (ah1==1){
// Hour place 1 can be 1 in two instances 11:00 and 01:00 so we
// handle this here
if (ah2>0){
// If hour place 2 is not 0, then it is 11:00 and we can
// just decrement
ah1--;
}
else {
// It is 01:00 so we set to 12:59
ah1 = 2;
ah2 = 1;
}
}
else {
// We can just decrement
ah1--;
if (ah1==1 && ah2==1){
// We switched between am and pm here so we need to handle
if (aampm){
aampm = 0;
}
else {
aampm = 1;
}
}
}
}
else {
// We can just decrement
am2--;
}
}
}
static void DisplayIncrementedTime(void){
// Method for incrementing the time by 1 minute and then displaying it
IncrementTime();
DisplayTime();
}
static void DisplayDecrementedTime(void){
// Method for decrementing the time by 1 minute and then displaying it
DecrementTime();
DisplayTime();
}
static void DisplayIncrementedAlarm(void){
// Method for incrementing the alarm by 1 minute and then displaying it
IncrementTimeA();
DisplayTimeA();
}
static void DisplayDecrementedAlarm(void){
// Method for decrementing the alarm by 1 minute and then displaying it
DecrementTimeA();
DisplayTimeA();
}
static void TisA(void){
// Method to check determine when the alarm will activate
// If all digits of the clock are equal, we activate
if (m1==am1){
if (m2==am2){
if (h1==ah1){
if (h2==ah2){
if (ampm==aampm){
// Turn on the LED
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_0);
// Turn on the alarm
PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT | PWM_OUT_1_BIT, true);
PWMGenEnable(PWM0_BASE, PWM_GEN_0);
// Display text on screen
RIT128x96x4StringDraw("WAKE UP!", 40, 10, 15);
// Enable the interrupt so we can turn off the alarm
// or use the snooze button
GPIOPinIntEnable(GPIO_PORTF_BASE, GPIO_PIN_1);
}
}
}
}
}
}
//*****************************************************************************
//
// Interrupt handlers
//
//*****************************************************************************
void
SysTickIntHandler(void){
// Handle incrementing the proper digits
t++;
if (t==60){
IncrementTime();
t = 0;
}
}
void
GPIOEIntHandler(void)
{
// Clear the GPIO interrupt
GPIOPinIntClear(GPIO_PORTE_BASE, GPIO_PIN_2 | GPIO_PIN_3);
// Disable Interrupts
GPIOPinIntDisable(GPIO_PORTE_BASE, GPIO_PIN_2 | GPIO_PIN_3);
GPIOPinIntDisable(GPIO_PORTF_BASE, GPIO_PIN_0);
// If the clock has been set before, we need to disable SysTickInt
if (start==1){
SysTickIntDisable();
}
// Clear the OLED
RIT128x96x4Clear();
// If the left button got us here, display that we are in set clock mode
// If the right button got us here, display that we are in set alarm mode
if (GPIOPinRead(GPIO_PORTE_BASE, GPIO_PIN_2)==0){
RIT128x96x4StringDraw("Set Clock", 40, 0, 15);
DisplayTime();
}
else if (GPIOPinRead(GPIO_PORTE_BASE, GPIO_PIN_3)==0){
RIT128x96x4StringDraw("Set Alarm", 40, 0, 15);
DisplayTimeA();
}
// If the left button is held down enable the time to be set
while (GPIOPinRead(GPIO_PORTE_BASE, GPIO_PIN_2)==0){
// While the up button is being pressed, the clock will increment
if (GPIOPinRead(GPIO_PORTE_BASE, GPIO_PIN_0)==0){
// In order to slow the incrementing we count to 10000 first
x++;
if (x>9999){
// Show the increment
DisplayIncrementedTime();
x = 0;
}
}
// While the down button is being pressed, the clock will decrement
if (GPIOPinRead(GPIO_PORTE_BASE, GPIO_PIN_1)==0){
// In order to slow the decrementing we count to 10000 first
x++;
if (x>9999){
// Show the decrement
DisplayDecrementedTime();
x = 0;
}
}
}
// If the right button is held down enable the alarm to be set
while (GPIOPinRead(GPIO_PORTE_BASE, GPIO_PIN_3)==0){
// While the up button is being pressed, the clock will increment
if (GPIOPinRead(GPIO_PORTE_BASE, GPIO_PIN_0)==0){
// In order to slow the decrementing we count to 10000 first
x++;
if (x>9999){
// Show the increment
DisplayIncrementedAlarm();
x = 0;
}
}
// While the down button is being pressed, the clock will decrement
if (GPIOPinRead(GPIO_PORTE_BASE, GPIO_PIN_1)==0){
// In order to slow the decrementing we count to 10000 first
x++;
if (x>9999){
// Show the decrement
DisplayDecrementedAlarm();
x = 0;
}
}
alarmSet = 1;
}
RIT128x96x4Clear();
// Enable the interrupts
GPIOPinIntEnable(GPIO_PORTE_BASE, GPIO_PIN_2 | GPIO_PIN_3);
GPIOPinIntEnable(GPIO_PORTF_BASE, GPIO_PIN_0);
// If the start variable is not set, we set it and start SysTick
if (!start){
start++;
t = 0;
SysTickIntEnable();
SysTickEnable();
}
else {
SysTickIntEnable();
}
}
void
GPIOFIntHandler(void)
{
// Clear the GPIO interrupt.
GPIOPinIntClear(GPIO_PORTF_BASE, GPIO_PIN_1);
y = 0;
// Counter for how long the snooze button was pressed
while (GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_1)==0){
y++;
}
// If the snooze button was held long enough, add 5 minutes to the alarm
if (y>500000){
int z;
for (z=0; z<5; z++){
IncrementTimeA();
}
}
// Clear the screen
RIT128x96x4Clear();
// Turn off the LED
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2);
// Turn off the alarm
PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT | PWM_OUT_1_BIT, false);
PWMGenDisable(PWM0_BASE, PWM_GEN_0);
// Disable the interrupt so that snooze and turn off alarm cannot be used
GPIOPinIntDisable(GPIO_PORTF_BASE, GPIO_PIN_1);
}
//*****************************************************************************
//
// Main Program
//
//*****************************************************************************
int
main(void)
{
unsigned long ulPeriod;
// Set the clocking to run directly from the crystal.
SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_8MHZ);
// Initialize the OLED display and write status.
RIT128x96x4Init(1000000);
// Enable the peripherals used by this application
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);
// Set GPIO F0 and G1 as PWM pins. They are used to output the PWM0 and
// PWM1 signals.
GPIOPinTypePWM(GPIO_PORTG_BASE, GPIO_PIN_1);
// Compute the PWM period based on the system clock.
ulPeriod = SysCtlClockGet() / 440;
// Set the PWM period to 440 (A) Hz.
PWMGenConfigure(PWM0_BASE, PWM_GEN_0,
PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC);
PWMGenPeriodSet(PWM0_BASE, PWM_GEN_0, ulPeriod);
// Set PWM0 to a duty cycle of 25% and PWM1 to a duty cycle of 75%.
PWMPulseWidthSet(PWM0_BASE, PWM_OUT_0, ulPeriod / 4);
PWMPulseWidthSet(PWM0_BASE, PWM_OUT_1, ulPeriod * 3 / 4);
// Enable the PWM0 and PWM1 output signals.
PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT | PWM_OUT_1_BIT, true);
// Configure the 'up' button as input and enable the pin to interrupt on
// the falling edge (i.e. when the push button is pressed).
GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_0);
GPIOPadConfigSet(GPIO_PORTE_BASE, GPIO_PIN_0,
GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);
// Configure the 'down' button as input and enable the pin to interrupt on
// the falling edge (i.e. when the push button is pressed).
GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_1);
GPIOPadConfigSet(GPIO_PORTE_BASE, GPIO_PIN_1, GPIO_STRENGTH_2MA,
GPIO_PIN_TYPE_STD_WPU);
// Configure the 'left' button as input and enable the pin to interrupt on
// the falling edge (i.e. when the push button is pressed).
GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_2);
GPIOPadConfigSet(GPIO_PORTE_BASE, GPIO_PIN_2, GPIO_STRENGTH_2MA,
GPIO_PIN_TYPE_STD_WPU);
// Configure the 'right' button as input and enable the pin to interrupt on
// the falling edge (i.e. when the push button is pressed).
GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_3);
GPIOPadConfigSet(GPIO_PORTE_BASE, GPIO_PIN_3, GPIO_STRENGTH_2MA,
GPIO_PIN_TYPE_STD_WPU);
GPIOIntTypeSet(GPIO_PORTE_BASE, GPIO_PIN_2 | GPIO_PIN_3,
GPIO_FALLING_EDGE);
GPIOPortIntRegister(GPIO_PORTE_BASE, GPIOEIntHandler);
GPIOPinIntEnable(GPIO_PORTE_BASE, GPIO_PIN_2 | GPIO_PIN_3);
IntEnable(INT_GPIOE);
// Configure the LED
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2);
// Configure the select buttons as input and enable the pin to interrupt on
// the falling edge (i.e. when the push button is pressed).
GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_1);
GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_1, GPIO_STRENGTH_2MA,
GPIO_PIN_TYPE_STD_WPU);
GPIOIntTypeSet(GPIO_PORTF_BASE, GPIO_PIN_1, GPIO_FALLING_EDGE);
GPIOPortIntRegister(GPIO_PORTF_BASE, GPIOFIntHandler);
GPIOPinIntEnable(GPIO_PORTF_BASE, GPIO_PIN_1);
IntEnable(INT_GPIOF);
// Initial time to display
static char pcInitTime[10];
usprintf(pcInitTime, "%d%d:%d%d AM", h2, h1, m2, m1);
// Set the time between SysTick interrupts and register the interrupt handle
SysTickPeriodSet(SysCtlClockGet());
SysTickIntRegister(SysTickIntHandler);
// Begin a blinking display of the initial start message
while (!start){
int a;
for (a=0; a<300000; a++){
if (a%20000==0){
RIT128x96x4StringDraw(pcInitTime, 40, 40, a/20000);
}
}
}
// The clock has started so we can clear the message
RIT128x96x4Clear();
// Loop forever
while(1)
{
// Display the updated time
DisplayTime();
// Check if we should sound the alarm
TisA();
}
}