By the way:
- Always, always, always, always, always, always, always, always, always start with a schematic !
1 Like
Hello danq84
Find below a simple solution coded in C++. You may need to mod the port pin addresses.
/* BLOCK COMMENT
ATTENTION: This Sketch contains elements of C++.
https://www.learncpp.com/cpp-tutorial/
Many thanks to LarryD
https://europe1.discourse-cdn.com/arduino/original/4X/7/e/0/7e0ee1e51f1df32e30893550c85f0dd33244fb0e.jpeg
https://forum.arduino.cc/t/coding-multiple-switches-servo-on-uno/955336
*/
#define ProjectName "Coding multiple switches/servo on Uno"
// INCLUDES
#include <Servo.h>
/*
Servo - Class for manipulating servo motors connected to Arduino pins.
attach(pin ) - Attaches a servo motor to an I/O pin.
attach(pin, min, max ) - Attaches to a pin setting min and max values in microseconds
default min is 544, max is 2400
write() - Sets the servo angle in degrees. (invalid angle that is valid as pulse in microseconds is treated as microseconds)
writeMicroseconds() - Sets the servo pulse width in microseconds
read() - Gets the last written servo pulse width as an angle between 0 and 180.
readMicroseconds() - Gets the last written servo pulse width in microseconds. (was read_us() in first release)
attached() - Returns true if there is a servo attached.
detach() - Stops an attached servos from pulsing its I/O pin.
*/
// HARDWARE AND TIMER SETTINGS
// YOU MAY NEED TO CHANGE THESE CONSTANTS TO YOUR HARDWARE AND NEEDS
constexpr byte ButtonPins[] {A0, A1}; // portPin o---|button|---GND
constexpr byte LedPins[] {2, 3, 4, 5, 6, 7, 8, 9}; // portPin o---|220|---|LED|---GND
#define OutPutTest
constexpr unsigned long OutPutTestTime {100};
// CONSTANT DEFINITION
enum {One, Two, Three, Four,Five,Six,Seven,Eight};
// VARIABLE DECLARATION AND DEFINITION
unsigned long currentTime;
struct TIMER { // has the following members
unsigned long duration; // memory for interval time
unsigned long stamp; // memory for actual time
bool onOff; // control for start/stop
};
struct BUTTON { // has the following members
byte pin; // port pin
bool statusQuo; // current state
TIMER scan; // see timer struct
};
struct SERVO {
int minimum;
int maximum;
int start_;
int pin;
Servo device;
} servos[] {
{0, 180, 90, 10},
};
constexpr int SizeOfLeds {sizeof(LedPins) / sizeof(LedPins[0] / 2)};
struct KNOPPIN {
BUTTON knop;
int counter;
byte led[SizeOfLeds];
TIMER stepper;
};
KNOPPIN knopPins[] {
{ButtonPins[One], false, 20, 0, true, 0, LedPins[One], LedPins[Two], LedPins[Three], LedPins[Four], 1000, 0, false},
{ButtonPins[Two], false, 20, 0, true, 0, LedPins[Five], LedPins[Six], LedPins[Seven], LedPins[Eight], 1000, 0, false},
};
// -------------------------------------------------------------------
void setup() {
Serial.begin(9600);
Serial.println(F("."));
Serial.print(F("File : ")), Serial.println(__FILE__);
Serial.print(F("Date : ")), Serial.println(__DATE__);
Serial.print(F("Project: ")), Serial.println(ProjectName);
pinMode (LED_BUILTIN, OUTPUT); // used as heartbeat indicator
// https://www.learncpp.com/cpp-tutorial/for-each-loops/
for (auto Input : ButtonPins) pinMode(Input, INPUT_PULLUP);
for (auto Output_ : LedPins) pinMode(Output_, OUTPUT);
#ifdef OutPutTest
// check outputs
for (auto Output_ : LedPins) digitalWrite(Output_, HIGH), delay(OutPutTestTime);
for (auto Output_ : LedPins) digitalWrite(Output_, LOW), delay(OutPutTestTime);
#endif
for (auto servo : servos) servo.device.attach(servo.pin);
}
void loop () {
currentTime = millis();
digitalWrite(LED_BUILTIN, (currentTime / 500) % 2);
bool trigger = true;
for (auto &knopPin : knopPins) {
if (currentTime - knopPin.knop.scan.stamp >= knopPin.knop.scan.duration) {
knopPin.knop.scan.stamp = currentTime;
int stateNew = digitalRead(knopPin.knop.pin) ^ 1;
if (knopPin.knop.statusQuo != stateNew) {
knopPin.knop.statusQuo = stateNew;
Serial.println(stateNew ? "pressed" : "released");
if (stateNew) {
knopPin.stepper.stamp = 0;
knopPin.stepper.onOff = true;
}
}
}
if (currentTime - knopPin.stepper.stamp >= knopPin.stepper.duration && knopPin.stepper.onOff) {
knopPin.stepper.stamp = currentTime;
digitalWrite(knopPin.led[knopPin.counter], HIGH);
if (++knopPin.counter == SizeOfLeds) knopPin.stepper.onOff = false;
}
}
for (auto LedPin : LedPins) trigger = trigger && digitalRead(LedPin);
servos[One].device.write(trigger ? servos[One].maximum : servos[One].minimum);
}
Have a nice day and enjoy coding in C++.
Thank you for both the code assistance/lesson and the instructions on how to use the forum(i.e., starting with a schematic)! What is the schematic software you are using? Is it easy to learn?
The software I use is no longer available (called WinQcad)
However, there is free software out there that is as good or better.
Example:
- KiCAD
- EasyEDA
- and others
Look at YouTube for instructional videos.
Okay, I tried to "do my stuff" and everything works fine except the servo doesn't move so I'm assuming I've done a noob mistake(s). Thanks for pointing me to schematic software.
#define LEDon HIGH
#define LEDoff LOW
#define switchPushed LOW
#define switchReleased HIGH
const byte leds[] = {3, 4, 5, 6,};
const byte leds2[] = {7, 8, 9, 10,};
const byte heartbeatLED = 13;
const byte pushButton1 = 2;
const byte pushButton2 = 11;
byte counter1 = 0;
byte counter2 = 0;
byte lastPushButton1 = switchReleased;
byte lastPushButton2 = switchReleased;
unsigned long switchMillis;
unsigned long yswitchMillis;
unsigned long lastHeartbeatMillis;
// Below this is the servo code ***********************
#include <Servo.h>
Servo myservo; // creat servo object to control a servo
int pos = 0; // variable to store the servo position
// end of servo setup code
//************************************************************************
void setup()
{
myservo.attach(12); // attaches servo on pin 12 to the servo object
Serial.begin(115200);
pinMode(heartbeatLED, OUTPUT);
//**********************************
for (byte x = 0; x < sizeof(leds); x++)
{
pinMode(leds[x], OUTPUT);
digitalWrite(leds[x], LOW);
}
//**********************************
for (byte x = 0; x < sizeof(leds2); x++)
{
pinMode(leds2[x], OUTPUT);
digitalWrite(leds2[x], LOW);
}
pinMode(pushButton1, INPUT_PULLUP);
pinMode(pushButton2, INPUT_PULLUP);
} //END of setup()
//************************************************************************
void loop()
{
//********************************** h e a r t b e a t T I M E R
if (millis() - lastHeartbeatMillis >= 500)
{
//restart this TIMER
lastHeartbeatMillis = millis();
//toggle the LED
digitalWrite(heartbeatLED, ! digitalRead(heartbeatLED));
}
//********************************** c h e c k S w i t c h e s T I M E R
//is it time to check the switches ?
if (millis() - switchMillis >= 50)
{
//restart this TIMER
switchMillis = millis();
checkSwitches();
}
if (counter1 == 4 && counter2 == 4)
for (pos = 0; pos <= 90; pos += 1) { //goes from 0 to 90 degrees
myservo.write(pos); // tell servo to go to position in variable 'pos'
delay(15); // waits 15 ms for the servo to reach the position
}
} //END of loop()
//************************************************************************
void checkSwitches()
{
byte state;
//********************************** s w i t c h 1
state = digitalRead(pushButton1);
if (lastPushButton1 != state)
{
//update to the new state
lastPushButton1 = state;
//*****************
//is the switch pushed ?
if (state == switchPushed)
{
digitalWrite(leds[counter1], LEDon);
counter1++;
if (counter1 > sizeof(leds))
{
counter1 = sizeof(leds);
}
}
} //END of switch1
//********************************** s w i t c h 2
state = digitalRead(pushButton2);
if (lastPushButton2 != state)
{
//update to the new state
lastPushButton2 = state;
//*****************
//is the switch pushed ?
if (state == switchPushed)
{
digitalWrite(leds2[counter2], LEDon);
counter2++;
if (counter2 > sizeof(leds2))
{
counter2 = sizeof(leds2);
}
}
} //END of switch 2
} //END of checkSwitches()
//*************************************
What do your debug prints tell you is happening with your code?
Schematic software can be nice, but really a hand drawn schematic is much easier, no learning curve except what makes a good schematic vs. a bad one, or a useful one from a useless one, neither of which any schematic cad program is going to help you along with much.
A schematic diagram is occasionally overkill. Many times a block diagram just showing your components and the signals that go between them is more than halfway helpful.
a7
To pass, you must ask 5 programming questions (that you do not understand) about the attached sketch:
//
// https://forum.arduino.cc/t/coding-multiple-switches-servo-on-uno/955336
//
// Version YY/MM/DD Comments
// ======= ======== =======================================================
// 1.00 22/02/05 Running code
#include <Servo.h>
Servo myServo;
//**********************************
#define LEDon HIGH
#define LEDoff LOW
#define switchPushed LOW
#define switchReleased HIGH
#define ENABLED true //we are timing the servo
#define DISABLED false //we are not timing the servo
//**********************************
const byte leds1[] = {3, 4, 5, 6,};
const byte leds2[] = {7, 8, 9, 10,};
const byte pushButton1 = 2;
const byte pushButton2 = 11;
const byte servoPin = 12;
const byte heartbeatLED = 13;
bool servoFlag = DISABLED;
const byte servoHomePosition = 0;
const byte servoMaximumPosition = 180;
byte counter1 = 0;
byte counter2 = 0;
byte lastPushButton1 = switchReleased;
byte lastPushButton2 = switchReleased;
//TIMER stuff
unsigned long lastHeartbeatMillis;
unsigned long switchMillis;
unsigned long servoMillis;
const unsigned long servoTime = 5 * 1000ul; //5 seconds
//const unsigned long servoTime = 24 * 60 * 60 * 1000ul; //24 hours
//************************************************************************
void setup()
{
pinMode(pushButton1, INPUT_PULLUP);
pinMode(pushButton2, INPUT_PULLUP);
//**********************************
for (byte x = 0; x < sizeof(leds1); x++)
{
pinMode(leds1[x], OUTPUT);
digitalWrite(leds1[x], LOW);
}
//**********************************
for (byte x = 0; x < sizeof(leds2); x++)
{
pinMode(leds2[x], OUTPUT);
digitalWrite(leds2[x], LOW);
}
//**********************************
pinMode(heartbeatLED, OUTPUT);
pinMode(servoPin, OUTPUT);
myServo.attach(servoPin);
myServo.write(servoHomePosition);
} //END of setup()
//************************************************************************
void loop()
{
//********************************** h e a r t b e a t T I M E R
//toggle the heartbeat LED every 500ms
if (millis() - lastHeartbeatMillis >= 500)
{
//restart this TIMER
lastHeartbeatMillis = millis();
//toggle the LED
digitalWrite(heartbeatLED, ! digitalRead(heartbeatLED));
} //END of this TIMER
//********************************** c h e c k S w i t c h e s T I M E R
//is it time to check the switches ?
if (millis() - switchMillis >= 50)
{
//restart this TIMER
switchMillis = millis();
checkSwitches();
} //END of this TIMER
//********************************** s e r v o T I M E R
//if enable, is it time to reset the servo ?
if (servoFlag == ENABLED && millis() - servoMillis >= servoTime)
{
//disable this TIMER
servoFlag = DISABLED;
//turn off all LEDs
//****************
for (byte x = 0; x < sizeof(leds1); x++)
{
pinMode(leds1[x], OUTPUT);
digitalWrite(leds1[x], LEDoff);
}
//****************
for (byte x = 0; x < sizeof(leds2); x++)
{
digitalWrite(leds2[x], LEDoff);
}
//get ready for the next sequence
counter1 = 0;
counter2 = 0;
//return the servo to the home position
myServo.write(servoHomePosition);
} //END of this TIMER
//**********************************
//other non-blocking code goes here
//**********************************
} //END of loop()
//************************************************************************
void checkSwitches()
{
byte state;
//********************************** s w i t c h 1
state = digitalRead(pushButton1);
//was there a change in switch state ?
if (lastPushButton1 != state)
{
//update to the new state
lastPushButton1 = state;
//*****************
//if we are not timing the servo, is the switch pushed ?
if (servoFlag == DISABLED && state == switchPushed)
{
//don't go over the number of LEDs
if (counter1 >= sizeof(leds1))
{
counter1 = sizeof(leds1) - 1;
}
digitalWrite(leds1[counter1], LEDon);
counter1++;
//if all LEDs are ON, it's time to operate the servo ?
if (counter1 == sizeof(leds1) && counter2 == sizeof(leds2))
{
//move the servo to the maximum position
myServo.write(servoMaximumPosition);
//enable the servo TIMER
servoFlag = ENABLED;
//start the TIMER
servoMillis = millis();
}
} //END of if (servoFlag == DISABLED && state == switchPushed)
} //END of switch 1
//********************************** s w i t c h 2
state = digitalRead(pushButton2);
//was there a change in switch state ?
if (lastPushButton2 != state)
{
//update to the new state
lastPushButton2 = state;
//*****************
//if we are not timing the servo, is the switch pushed ?
if (servoFlag == DISABLED && state == switchPushed)
{
//don't go over the number of LEDs
if (counter2 >= sizeof(leds2))
{
//do not go over the size of the array
counter2 = sizeof(leds2) - 1;
}
digitalWrite(leds2[counter2], LEDon);
counter2++;
//if all LEDs are ON, it's time to operate the servo ?
if (counter1 == sizeof(leds1) && counter2 == sizeof(leds2))
{
//move the servo to the maximum position
myServo.write(servoMaximumPosition);
//enable the servo TIMER
servoFlag = ENABLED;
//start the TIMER
servoMillis = millis();
}
} //END of if (servoFlag == DISABLED && state == switchPushed)
} //END of switch 2
//**********************************
} //END of checkSwitches()
//************************************************************************
Whew ... a task master, huh? Well five should be no problem. Here goes:
- Is there a reason you started with the two servo statements?
- I don't see the int pos = 0; // variable to store the servo position. Not necessary?
- What is the function of "bool servoFlag = DISABLED;
- Why the 5 second "const unsigned long servoTime"? Is the servo being "turned off or back to its original position after 5 second (and are the LEDs being turned off)?
- What other "non-blocking code" is the "locator" talking about?
- Is the checkSwitches() a way to run the void checkSwitches "sub-program"?
So question 4 was partially answered when I tried it, but is that line of code doing that after something else is checked?
A few of the questions asked were a bit lazy, you have to ask 2 more questions as a penalty.
Please reword, don't understand what you are asking ?
You do know that we are setting how long we want the servo TIMER to run for ?
const unsigned long servoTime = 5 * 1000ul; //5 seconds
const unsigned long servoTime = 24 * 60 * 60 * 1000ul; //24 hours
const unsigned long servoTime = 10 * 24 * 60 * 60 * 1000ul; //10 days
if (servoFlag == ENABLED && millis() - servoMillis >= servoTime)
Okay, I'll try and not be lazy, but I've already run the snowblower for 2.5 hours and shoveled for another .5 so I'm feeling a little lazy. Here goes:
- The void thing has me confused. What I've read says it means no information is being returned. What good is that if there is no info?
- I don't get the whole "PULLUP" thing. What I've read implies that it changes the status of a momentary switch. If that is true, why do that?
Forget my confusing comment about the previous question 4.
void checkSwitches()
{
. . .
}
void means the function checkSwitches does not return anything when you ‘call’ it.
This this function can still, however, change variables in the sketch such as flags, counters etc.
The following function returns an integer.
int addTwoNumbers( int A, int B)
{
return A + B;
}
int says the function addTwoNumbers returns an integer.
You ‘call’ it like this:
myAnswer = addTwoNumbers( 3, 4);
myAnswer becomes 7, notice the equals sign.
A floating input (nothing connected to the pin) on the Arduino has a resistance (impedance) of infinity (well ~100 million ohms.)
When you put a LOW (0V) on the pin, the pin will read LOW.
When you take that LOW away from the pin, it will still read a LOW.
When you put a HIGH (5V) on the pin, the pin will read HIGH.
When you take that HIGH away from the pin, it will still read a HIGH.
This phenomena is all do to the high input resistance of the pin.
We must somehow make the pin go to a HIGH when we remove the LOW from that pin (and vice versa).
We do this by adding an external resistor (usually < 100k) to the pin then going to 5V.
However, we can use a built in pull-up resistor inside the controller to do the same, saving on one component.
Each I/O pin has its own pull-up resistor that we can turn on using software.
Watch these:
Calgary Canada here, where are you ?
Mid-state Maine.
Luxury, I've just been out, started the car, opened all the car windows, gone and got some KFC, come home, eaten lunch, now putting feet up.
Watching Winter Olympics on Tablet.
You northerners don't know how to live.
Tom...(Aussie.. Sunny, 22C) 
Did you missed post #34 and #35.