Due at the beginning of class on Wednesday, March 27th

(image from clipart.guru)

# Assignment

In basketball, it’s possible to score one, two, or three points at a time. You and your friends want an easy scorekeeping system which is designed to tally the number of points that your team has. “If the other team sees this awesome system,” you think, “they will be so intimidated by how clever we are at building things that they’ll become terrible at basketball.” It’s a foolproof plan.

Your clever scoring system will consist of four buttons (described below), three indicator LEDs, and `Serial` feedback that specifies the chip’s internal timer, the last type of basket made, and the current score. Buttons:

1. The one point button. When pushed, add one point to the score, announce
`millis = xxxxx, free throw scored, x points`
and light a green LED for two seconds.

2. The two point button. When pushed, add two points to the score, announce
`millis = xxxxx, field goal scored, x points`
and light a yellow LED for two seconds.

3. The three point button. When pushed, add three points to the score and announce
`millis = xxxxx, three pointer scored, x points`
and light a red LED for two seconds.

4. The reset button. When pushed, announce
`reset`
and change the score to zero.

An example interaction, to illustrate the intended outcome: the user pushes the “reset” button about two seconds after the Arduino turns on, and the `Serial` feedback reads:

```millis = 2492, reset, 0 points
```

Then, about 10 seconds after the Arduino turns on, the user pushes the three point button. The red LED lights for two seconds, and the `Serial` feedback now reads:

```millis = 2492, reset, 0 points
millis = 10284, three pointer scored, 3 points
```

Note that there is no `Serial` feedback until a button is pushed. If, about 20 seconds after the Arduino was turned on, the user were to then push the two point button: the yellow LED would illuminate for one second, and the `Serial` feedback would read:

```millis = 2492, reset, 0 points
millis = 10284, three pointer scored, 3 points
millis = 20625, field goal scored, 5 points
```

A final important note: each button’s LED is supposed to light for two seconds after that button was pushed—but during that time, it’s important that the board is still able to receive a new button push on that, or any different button. This means that you can’t simply use a `delay()` to keep that LED on—you’ve got to use the chip’s on-board timer, called `millis()`, to help you out.

# Deliverables

All deliverables are due at the start of class on Wednesday, March 27th:

1. A working machine which functions as described above, to be demonstrated at the start of class
2. A schematic drawing of the machine’s wiring (printed or drawn on an 8-1/2 x 11” sheet of lined or blank paper)
3. Code submission to this assignment’s Canvas page; your file name should have the form `andrewID-hw7.ino`. Please follow the same code conventions we’ve previously defined:

Follow the below pattern (with your own, updated information!) in a comment block at the top of the code you submit:

``````/*
* Homework 7
* Andrew Carnegie (acarnegi)
* 1 hour 25 minutes
*
* Collaboration: Ada Lovelace helped me understand
* variables and we worked on the code together.
*
* Challenge: I tried to write my own function but
* it did not go as planned. It took me an extra hour!
* I was held up with bracket trouble the whole time,
* it seems.
*
* Next time: I'll start by writing comments or pseudo-code
* before trying to write the actual code. I think this
* will reduce my getting tangled around the code
* structure.
*
* Summary: The code below blinks three LEDs according
* to a pre-defined pattern.
*
* Inputs: none
*
* Outputs: 1 LED
*/
``````

Use good code practice:

• select good names for variables, including camelCase names for variables which will change values and ALLCAPS for those which won’t
• use the `const` qualifier for any variable that won’t change, such as pin assignments, e.g. `const int BUTTONPIN = 7` or other constants, e.g. `const float PI = 3.1416`.

Graded schematics and code will be returned to students on Wednesday Apr. 3rd.

# Collaboration

Limited collaboration with your colleagues is permitted. You must build your own circuit and write your own code, but you can talk with other students to get advice and reason through the problem together. You are not permitted to copy anybody else’s code (whether that person is in this class or not). You are permitted to use any internet/book/etc. resource you’d like for guidance, so long as you do not copy code verbatim from such a source.

# Feedback

points assignment
3 inputs wired properly (and using `INPUT_PULLUP` configuration)
3 outputs wired properly (current-limiting resistors)
3 schematic (legible, clean, and valid)
5 serial feedback (working as described above, and formatted properly)
6 code written cleanly, clearly, and with appropriate commenting practice
20 total

# `millis()`

The Arduino has a built-in timer that begins counting as soon as the board gets power. It counts up in milliseconds, which means the number gets pretty big, pretty quickly. This timer is not affected by a `delay()` statement or any other thing going on in your code—it’s a very reliable value.

To find out precisely how many milliseconds it’s been since the chip turned on, you simply run the built-in function `millis()`, which will return the answer. For instance, if you want to find out where `millis()` is at this moment, simply run

``````Serial.println(millis());
``````

and there you go, you’ve got the value displayed.

The power of `millis()` is that by referring to this active timer, you can make things happen on a schedule without using `delay()` statements. This is a big deal! It means that multiple tasks can run concurrently on their own schedules, without interfering with each other.

See the Blink without blocking section of Code bites for some implementation details.

## Using `millis()` to run a one-second timer: the event-loop model

Here is code, which we developed together in class, which outlines in short form how to use `millis()` to time a task:

``````unsigned long timer = 0;

void setup() {}

void loop() {
// something I want to run every second
if (millis() - timer >= 1000){    // greater than or equal!
// this happens once per second
timer = millis();
}
}
``````

# Help! My buttons keep pressing!

Why do your buttons keep pressing over and over? Because once you’ve gotten rid of the `delay()`s in your code, those button-press detections are able to run over and over as the `loop()` keeps executing repeatedly. Part of the challenge of this assignment is solving this problem.

You’ll need to get around this problem by “debouncing” your button presses. There’s a tutorial on that topic in the left navigation bar featuring example code, but here’s a one-sentence clue of how you might want to approach the problem: instead of detecting the current button state on each loop, detect the state change from unpressed to pressed.

Hints:

• Use some global state variables, perhaps like this:
``````bool buttonState = true;
bool lastButtonState = true;
``````
• Use these variables in your loop to detect when a button transitions from unpressed to pressed
• Be careful to update the variables at the appropriate times
• Recall that `true` and `HIGH` are synonymous, and `false` and `LOW` are as well. (This is somewhat imprecise speech, but it basically holds true in Arduinoland.)