Multitasking in Arduino using millis() function - function

Question

I'm thinking of building a DIY gokart-offroad type of car from scrap vehicle parts. And as electronics, I'm planning on using my Arduino Uno for controlling basically everything. So I just made a gear display which lets me know which gear I'm currently on. And a simple parking sensor.
If I'm too close to an object the parking sensor buzzer will blink. And I can't blink with delay() functions because if I try to shift up when it's blinking, the input won't register because delay is a blocking function. So I tried to use millis instead but seems like it also doesn't register.
The concept is easy. I will have two buttons on each side of my shiftstick. And when I shift up the button gets pressed therefore the 7 segment display adds one. And another one for downshifting.
I have not added the reverse gear yet, but still when the parking sensor function is working, I still can't push the buttons for a good amount of time.
I hope you guys could understand what I'm trying to say. I just started coding in Arduino so I don't have enough experience. I'm leaving the .ino file as a code block. I tried to explain everything in the code. Hopefully someone knows the solution for this. Thanks in advance...
// Setting up the pins for 7-Segment-Display.
const int E = 13;
const int D = 12;
const int C = 11;
const int DP = 10;
const int G = 9;
const int F = 8;
const int A = 7;
const int B = 6;
// Setting up the counter for gear shifting.
int gearCount = 0;
// Setting up the button states and button pin for state-change detectors.
int buttonAddPin = 5;
int buttonAddState = 0;
int previousButtonAddState = 0;
// And this is for downshifting.
int buttonSubstractPin = 4;
int buttonSubstractState = 0;
int previousButtonSubstractState = 0;
// Adding buzzer for parking sensor.
const int buzzerPin = 3;
int buzzerTone = 0;
// Adding parking sensor.
const int trigPin = 2;
const int echoPin = 1;
long duration;
int distance;
// Adding non-delay blinker with millis for buzzer to blink when sensor detects an object.
unsigned long previousTime = 0;
/*---------------------------------- FUNCTIONS FOR SHIFTING -------------------------------------------------*/
// "zero" function is the series of commands for displayıng 0 on the 7-Segment corresponding to neutral gear.
void zero()
{
digitalWrite(A, LOW);
digitalWrite(B, LOW);
digitalWrite(C, LOW);
digitalWrite(D, LOW);
digitalWrite(E, LOW);
digitalWrite(F, LOW);
digitalWrite(G, HIGH);
digitalWrite(DP, HIGH);
}
// "one" function is the series of commands for displaying 1 on the 7-Segment-Display corresponding to 1st gear.
void one()
{
digitalWrite(A, HIGH);
digitalWrite(B, LOW);
digitalWrite(C, LOW);
digitalWrite(D, HIGH);
digitalWrite(E, HIGH);
digitalWrite(F, HIGH);
digitalWrite(G, HIGH);
digitalWrite(DP, HIGH);
}
// "two" function is the series of commands for displaying 2 on the 7-Segment-Display corresponding to 2nd gear.
void two()
{
digitalWrite(A, LOW);
digitalWrite(B, LOW);
digitalWrite(C, HIGH);
digitalWrite(D, LOW);
digitalWrite(E, LOW);
digitalWrite(F, HIGH);
digitalWrite(G, LOW);
digitalWrite(DP, HIGH);
}
// "three" function is the series of commands for displaying 3 on the 7-Segment-Display corresponding to 3rd gear.
void three()
{
digitalWrite(A, LOW);
digitalWrite(B, LOW);
digitalWrite(C, LOW);
digitalWrite(D, LOW);
digitalWrite(E, HIGH);
digitalWrite(F, HIGH);
digitalWrite(G, LOW);
digitalWrite(DP, HIGH);
}
// And now the main function that we are going to call in "void loop" to determine which gear we are on.
void gearDisplay()
{
buttonAddState = digitalRead(buttonAddPin); // And now the button state change detector for shifting up is ready. As you can see when I push the button
// program adds 1 to gearCount variable. So now gearCount is 1. Therefore the 7-Segment-Display will show
if(buttonAddState != previousButtonAddState){ // 1 on it. We will do this a bit later.
if(buttonAddState == HIGH){
gearCount++;
}
delay(50);
}
previousButtonAddState = buttonAddState;
// Now for downshifting.
buttonSubstractState = digitalRead(buttonSubstractPin);
if(buttonSubstractState != previousButtonSubstractState) {
if(buttonSubstractState == HIGH){
gearCount--;
}
delay(50);
}
previousButtonSubstractState = buttonSubstractState;
// Now we will call one of the 7-Segment-Display number functions according to the gearCount variable.
if(gearCount == 0){
zero();
}
else if(gearCount == 1){
one();
}
else if(gearCount == 2){
two();
}
else if(gearCount == 3){
three();
}
else if(gearCount > 3){ // Just making sure if we press buttons accidentally more than enough, it sets gearCount back to closest gear available.
gearCount--;
}
else if(gearCount < 0){ // Same with this one.
gearCount++;
}
}
// That was al for the gear panel. Now the hard part. The parking sensor.
/*---------------------------------------------- SHIFTING DONE ----------------------------------------------------*/
/*--------------------------------------------- PARKING SENSOR ------------------------------------------------------*/
void parkingSensor()
{
digitalWrite(trigPin, LOW); // Resetting trigPin
delayMicroseconds(2); // Delaying to prevent any issiues. ( I saw this online, most people do it like this so I also did.)
digitalWrite(trigPin, HIGH); // Creating a short soundwave.
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
duration = pulseIn(echoPin, HIGH); // Detecting the time that passes for the soundwave to reach back to the receiver.
distance = duration*0.034/2; // Simple math for calculating the distance between the obstacle and sensor.
unsigned long currentTime = millis(); // Store the current time for blinking the buzzers.
if((distance > 0) && (distance < 31)){ // If the distance is in between 0-31 buzz non-stop.
buzzerTone = 1000;
tone(buzzerPin, buzzerTone);
}
else if((distance > 30) && (distance < 76)){ // If the distance is between 30-76 buzz every 100 miliseconds.
if(currentTime - previousTime >= 100){
previousTime = currentTime;
if(buzzerTone == 1000){
buzzerTone = 0;
}
else {
buzzerTone = 1000;
}
tone(buzzerPin, buzzerTone);
}
}
else if((distance > 75) && (distance < 101)){ // If the distance is between 75-101 buzz every 300 miliseconds.
if(currentTime - previousTime >= 300){
previousTime = currentTime;
if(buzzerTone == 1000){
buzzerTone = 0;
}
else {
buzzerTone = 1000;
}
tone(buzzerPin, buzzerTone);
}
}
else if(distance > 100){ // If the distance is more than 100 don't buzz.
buzzerTone = 0;
tone(buzzerPin, buzzerTone);
}
}
/*------------------------------- PARKING SENSOR DONE -----------------------------------*/
// And this was, I guess, all I had to do but unfortunately it's not working...
void setup() {
pinMode(A, OUTPUT);
pinMode(B, OUTPUT);
pinMode(C, OUTPUT);
pinMode(D, OUTPUT);
pinMode(E, OUTPUT);
pinMode(F, OUTPUT);
pinMode(G, OUTPUT);
pinMode(DP, OUTPUT);
pinMode(buttonAddPin, INPUT);
pinMode(buttonSubstractPin, INPUT);
pinMode(buzzerPin, OUTPUT);
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
}
void loop() {
gearDisplay();
parkingSensor();
}
EDIT: Turns out that pulseIn()'s default duration is 1 second. And it's also a blocking function which blocks the buttons from registering inputs on every loop for 1 second. Changing that to smaller values, for example 10ms in my case, was enough and solved the issue. All credit goes to #CherryDT who solved this. Thanks a lot.
btw this is how the code should look like for 10ms:
pulseIn(echoPin, HIGH, 10000)
// Note that the duration in pulseIn() is in microsconds.

Answer 1

EDIT: Turns out that I misunderstood the question. Anyway, leaving this answer here because it answers "how to blink without blocking" which may be useful too.
The answer for the main problem would be: You are using pulseIn which also blocks until the pulse is received. The default timeout for pulseIn is one second, so if there is no object in view of your parking sensor, you are blocking for 1s every time! Since you are probably only interested in reasonably small distances anyway, you could just set a timeout of, say, 10ms (10000us):
pulseIn(echoPin, HIGH, 10000)
If this doesn't fit your requirements or is still too much of a delay though, consider writing your own code instead which measures the time without blocking, processing the button presses in the meantime. See this answer where someone had the exact same issue and solved it this way.
Basically, you could do something like this:
unsigned long pulseTimer = 0;
int lastEchoState = HIGH; // Initially HIGH so that the actual LOW triggers a "change"
void loop () {
int currentEchoState = digitalRead(echoPin);
// To set a timeout of the pulse, simulate a pulse if already waiting for too long
if (lastEchoState == LOW && micros() - pulseTimer > 1000000ul) {
currentEchoState = HIGH;
}
if (currentEchoState != lastEchoState) {
lastEchoState = currentEchoState;
if (currentEchoState == LOW) {
// Echo pulse over (or it's the initial loop iteration)
// Start counting time until echo
// We do this before sending the trigger because pulseIn would
// normally measure until the pulse is *over*, but for simplicity
// we measure until the pulse *starts*, so this implicitly shifts
// the result by our pulse duration, as trigger and echo pulse are
// usually of the same length
pulseTimer = micros();
// Send new trigger pulse
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
} else {
// Pulse came in, measure time
unsigned long pulseDelayTime = micros() - pulseTimer;
// **** DO SOMETHING WITH pulseDelayTime HERE! ****
}
}
// **** DO YOUR REGULAR BUTTON PROCESSING HERE! ****
}
You would do the blinking by setting the LED output to:
(millis() / 500) % 2
...to blink it, on every loop iteration*.
This would basically be LOW for 500ms and HIGH for 500ms, because dividing millis() by 500 (which won't have any fractional part because we are in integer world here) would give a number that increments every 500ms, and % 2 takes it modulo 2, i.e. it'd be 1 for odd and 0 for even numbers. And 1 and 0 are the same as HIGH and LOW for Arduino.
Example:
+----------+--------------+------------------+
| millis() | millis()/500 | (millis()/500)%2 |
+----------+--------------+------------------+
| ... | | |
| 1499 | 2 | 0 (LOW) |
| 1500 | 3 | 1 (HIGH) |
| 1501 | 3 | 1 (HIGH) |
| ... | | |
| 1999 | 3 | 1 (HIGH) |
| 2000 | 4 | 0 (LOW) |
| 2001 | 4 | 0 (LOW) |
| ... | | |
| 2499 | 4 | 0 (LOW) |
| 2500 | 5 | 1 (HIGH) |
| 2501 | 5 | 1 (HIGH) |
| ... | | |
+----------+--------------+------------------+
Cool project, by the way.
*: If you wanted to squeeze a bit more performance out of this, you could save the last pin state in a separate variable and do digitalWrite only when it changed. That's because digitalWrite is pretty slow actually, so you could avoid calling it every time unless an actual change is needed.