So it's a simple problem, I have several LEDs on a board where depending on their states it will trigger a command to fire a relay. Where I am stuck is figuring out how to get the Arduino to see a blinking LED, I have tried to bypass it all together but the code got larger than we wanted so it was scrapped and I am starting all over. Any ideas would be most helpful. Here is the basic code:
int Relay = 2;
int Led = 7;
int Ball = 8;
void setup()
{
Serial.begin(115200);
pinMode(Relay, OUTPUT);
pinMode(Led, INPUT);
pinMode(Ball, OUTPUT);
}
void loop()
{
digitalWrite (Relay, HIGH);
delay (500);
digitalWrite (Relay, LOW);
delay(300);
digitalRead(Led);
if(Led == HIGH)
{
digitalWrite(Ball, HIGH);
}
if(Led == LOW)
{
digitalWrite(Ball, LOW);
}
}
digitalRead(Led) throws away the value you are reading, and if (Led == LOW) is comparing a pin number with a voltage level, which is meaningless. You mean:
level = digitalRead(Led);
if (level == HIGH) { ...
Related
I have a really simple code that is not behaving how I would expect it to.
Here's the code:
int i;
void setup() {
Serial.begin(9600);
pinMode(13, OUTPUT);
}
void loop() {
//digitalWrite(13, HIGH);
i = random(1,5);
Serial.println(i);
digitalWrite(13, HIGH);
delay(1000);
digitalWrite(13, LOW);
}
With this code the LED only blinks when Serial Monitor is on and stays on while Serial Monitor is off. Another problem I have is that if I comment out the current digitalWrite(LED_BUILTIN, HIGH) and replace it with the one I have commented out then the LED wont blink even if Serial Monitor is off.
I have Arduino Micro
If you want to blink a LED, you need to add an extra delay when the LED is going from OFF to ON.
Currently you have:
LED ON -> wait -> LED OFF -> (instantly) LED ON -> wait etc
So what you see is just the LED continuously ON, to make it work add another delay(1000) before digitalWrite(13, HIGH) for example:
int i;
void setup() {
Serial.begin(9600);
pinMode(13, OUTPUT);
}
void loop() {
//digitalWrite(13, HIGH);
i = random(1,5);
Serial.println(i);
delay(1000);
digitalWrite(13, HIGH);
delay(1000);
digitalWrite(13, LOW);
}
I tested it on my Arduino Nano and it worked fine.
I cannot explain to myself why this code works properly in some cases and in some not. Here is the situation:
I am trying to switch a relay with the Arduino Nano. Therefore I took the "Blink" example as a guide. It should switch on for like 5 minutes and switch off for like 25 minutes. Here is the code:
// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin LED_BUILTIN as an output.
pinMode(LED_BUILTIN, OUTPUT);
pinMode(2, OUTPUT); // sets PIN 2 as switcher for the relay
}
// the loop function runs over and over again forever
void loop() {
int count = 0;
int run_pump = 300; // 5 Min run
int stop_pump = 1500; // 25 Min stop
digitalWrite(LED_BUILTIN, LOW); // turn the LED off (HIGH is the voltage level)
digitalWrite(2, HIGH); // turn the pump on
while(count < run_pump) {
count++;
delay(1000); // wait for a second
}
count = 0;
digitalWrite(LED_BUILTIN, HIGH); // turn the LED on by making the voltage LOW
digitalWrite(2, LOW); // turn the pump off
while(count < stop_pump) {
count++;
delay(1000); // wait for a second
}
}
if I run this code on the Arduino it will just switch on the relay forever. BUT: If I set run_pump and stop_pump for like 10 sec. it will work properly! Is there an explanation why this does not work with the bigger counters? It's so confusing....
so this code here works absolutely fine, but why does the code above not?
// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin LED_BUILTIN as an output.
pinMode(LED_BUILTIN, OUTPUT);
pinMode(2, OUTPUT); // sets PIN 2 as switcher for the relay
}
// the loop function runs over and over again forever
void loop() {
int count = 0;
int run_pump = 5; // 5 sec run
int stop_pump = 10; // 10 sec stop
digitalWrite(LED_BUILTIN, LOW); // turn the LED off (HIGH is the voltage level)
digitalWrite(2, HIGH); // turn the pump on
while(count < run_pump) {
count++;
delay(1000); // wait for a second
}
count = 0;
digitalWrite(LED_BUILTIN, HIGH); // turn the LED on by making the voltage LOW
digitalWrite(2, LOW); // turn the pump off
while(count < stop_pump) {
count++;
delay(1000); // wait for a second
}
}
Hope someone has a clue.... Thanks!
Tom
OK guys, I solved it. The problem was a cheap relay that was trying to communicate with the Arduino... Replacing it with a better one solved the whole problem. Thanks for the idea with the LED, this brought some stones to roll... :)
Currently working on a project where I need to turn on the motor for just 1 second if my rain sensor detects any rain. if no rain I will again rote backward for 1 second.
sensor and device that I'm using
Arduino MEGA
Rain Sensor
L298N Motor driver
but the problem is I'm unable to run the condition for 1 second.
Here is my current Arduino sketch
const int IN1 = 7;
const int IN2 = 6;
const int ENA = 9;
const int capteur_A = A0;
int val_analogique;
void setup() {
Serial.begin(9600);
pinMode(capteur_A, INPUT);
pinMode (IN1, OUTPUT);
pinMode (IN2, OUTPUT);
pinMode (ENA, OUTPUT);
}
void forward(){
analogWrite(ENA, 60);
digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);
}
void loop() {
val_analogique=analogRead(capteur_A);
Serial.println(val_analogique);
if(val_analogique<=300){
forward();
Serial.println("Going Forward");
}
else{
digitalWrite(IN1, LOW);
digitalWrite(IN2, LOW);
}
}
To let the Motor rotate for 1 second, you just have to wait and then stop it. You can use the delay() function to wait a specific number of milliseconds. The forward function would be:
void forward() {
analogWrite(ENA, 60); // Set power and direction for the motor
digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);
delay(1000); // Wait for 1000 milliseconds
digitalWrite(ENA, 0); // Stop the motor
digitalWrite(IN1, LOW);
digitalWrite(IN2, LOW);
}
And for the other direction it would be exactly the same, just with the two direction ports swapped:
void backward() {
analogWrite(ENA, 60); // Set power and direction for the motor
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
delay(1000); // Wait for 1000 milliseconds
digitalWrite(ENA, 0); // Stop the motor
digitalWrite(IN1, LOW);
digitalWrite(IN2, LOW);
}
Oh, and by the way, it would also be nice to call the ports OUT and not IN, as they're outputs and not inputs :)
You have to implement a simple state machine pseudo code as a starter:
long timer = 0;
bool conditionRain = false;
bool conditionNoRain = true;
setup() {}
loop() {
...
if(val_analogique<=300 && conditionRain == false) { // Condition rain detected
timer = millis(); // we start the timer
conditionRain = true; // set the state
conditionNoRain = false; // set the state
}
if (conditionRain == true && millis()-timer < 1000) { // Here is the timer check
... do motor for rain ...
}
// Assumption Since the motor should run for one second when the rain stops
if(val_analogique>=850 && conditionNoRain == false){ // Condition rain detected
timer = millis();
conditionRain = false; // set the state
conditionNoRain = true; // set the state
}
if (conditionNoRain == true && millis()-timer<1000){ // Here is the timer check
... do motor for no rain ...
}
Simple switching between states with timer function -there is no else because we always check the states if these are not fulfilled nothing should happen
Hi I am having a little trouble understanding the behaviour of what would seem a very simple issue.
I have 4 LED's and resistors linked up, with a push button. The idea is that I press the button and the LEDS light up sequentially, turning the previous one off.
This works fine, until it is time to restart the loop from the beginning where everything is ok in serial monitor, but the LEDS barely light up except number 4 which lights up normally.
Here is my code:
const int buttonPin = 6;
const int ledPin1 = 2;
const int ledPin2 = 3;
const int ledPin3 = 4;
const int ledPin4 = 5;
int buttonState = 0;
int pressed = 0;
void setup() {
{
Serial.begin (115200);
Serial.println ();
Serial.println ("Starting up");
}
pinMode(ledPin1, OUTPUT);
pinMode(ledPin2, OUTPUT);
pinMode(ledPin3, OUTPUT);
pinMode(ledPin4, OUTPUT);
pinMode(buttonPin, INPUT_PULLUP);
}
void loop()
{
if(digitalRead(buttonPin)==HIGH)
{
if(pressed==0)
{
pressed=1;
switch(buttonState)
{
case 0:
digitalWrite(ledPin1, LOW);
buttonState++;
break;
case 1:
digitalWrite(ledPin1, HIGH);
Serial.println ("1");
buttonState++;
break;
case 2:
digitalWrite(ledPin2, HIGH);
pinMode(ledPin1, LOW);
Serial.println ("2");
buttonState++;
break;
case 3:
digitalWrite(ledPin3, HIGH);
pinMode(ledPin2, LOW);
Serial.println ("3");
buttonState++;
break;
case 4:
digitalWrite(ledPin4, HIGH);
pinMode(ledPin3, LOW);
Serial.println ("4");
buttonState++;
break;
case 5:
digitalWrite(ledPin4, LOW);
Serial.println ("off");
buttonState=0;
return;
}
}
}
else
{
pressed=0;
}
}
Hope some of you more intelligent folks can shed some light on this unusual behaviour.
BTW I am VERY new to arduino programming so please take it easy.
You want to understand the difference between pinMode() and digitalWrite() functions.
pinMode(pin, mode) configures the specified pin to behave either as an input or an output. (doc)
digitalWrite(pin, value) writes a HIGH or a LOW value to a digital pin. (doc)
In your switch statement, you are changing pinMode from OUTPUT to INPUT.
pinMode(ledPin1, LOW)
is the same as
pinMode(ledPin1, INPUT)
because LOW and INPUT are both defined as 0x00.
When you change the pin mode to INPUT, you can no longer turn on your LED by calling digitalWrite(ledPin1, HIGH).
LED 4 works because you don't call pinMode(ledPin4, LOW) anywhere.
I think you wanted to call digitalWrite(ledPin1, LOW) instead of pinMode(ledPin1, LOW) in the switch statement.
I'm fairly new to coding, and I've been trying to write something to write a placeholder to a text document whenever a button attached to a GPIO pin on my RasPi is pressed:
//Write date function//
void record() {
ofstream myFile;
myFile.open("report.txt");
myFile << "Input at SPAM \n";
myFile.close();
}
//myRead function//
void myRead(int i){
if((digitalRead(4) == HIGH) && (i<5)) {
record();
digitalWrite(14, HIGH);
delay(500);
digitalWrite(14, LOW);
++i;
delay(500);
myRead(i);
}
else{
if((digitalRead(4) != HIGH) && (i<5)){
myRead(i);
}
}
}
int main() {
wiringPiSetup();
pinMode(12, OUTPUT);
pinMode(14, OUTPUT);
pinMode(4, INPUT);
digitalWrite(12, HIGH);
digitalWrite(14, LOW);
myRead(1);
digitalWrite(14, HIGH);
delay(5000);
digitalWrite(14, LOW);
return 0;
}
The code compiles without any complaints, but if I run it in terminal without a sudo command, I get a "segmentation fault" error.
When I run it with a sudo command, the program starts and then ends almost immediately.
For reference:
Pin 12 is providing power to a potential divider on the breadboard.
Pin 4 should take the input from this divider.
Pin 14 causes an LED to light whenever there is an input on pin 4.
Whenever I run the program and VERY QUICKLY press the button on the potential divider, the LED will light if I hold the button.
How can I get this to run properly without it stopping as soon as it starts?
I think there are several possible problems with myRead.
A minor rewrite could be:
void myRead(int i)
{
if((digitalRead(4) == HIGH) && (i<5)) {
record();
digitalWrite(14, HIGH);
delay(500);
digitalWrite(14, LOW);
++i;
delay(500);
myRead(i);
} else if((digitalRead(4) != HIGH) && (i<5)) {
myRead(i);
}
}
Notice that you have two calls to digitalRead -- this may lead to problems since the first one my return something different from HIGH and the second may return HIGH, meaning neither conditions are true.
You make a call to myRead with the same i in the alternative branch as the original call. If digitalRead returns something different from HIGH suffeciently many times, your stack will be full very fast and you'll get a segfault.
I'll propose a different version, that should be identical (baring any misunderstanding on my part):
void myRead(int i)
{
// as long as i is less than 5
while (i < 5) {
// busy wait for digitalRead(4) to be HIGH
while (digitalRead(4) != HIGH);
// do the main thing
record();
digitalWrite(14, HIGH);
delay(500);
digitalWrite(14, LOW);
++i;
delay(500);
}
}
Also please note that this is just plain C, not C++ (well, technically it's valid C++, but it's making no use of C++)