Combined loops not working in Arduino - loops

I have an arduino code which is doing tasks like this:
while (a=='A')
{
//do the task A
}
while (a=='B')
{
//do the task B
}
These loop run correctly when they are run separately. But the problem comes when I try to combine both loops i.e.
void loop ()
{
while (a=='A')
{
//do the task A
}
while (a=='B')
{
//do the task B
}
}
Below is the code in full details:
void loop()
{
////// admin
Serial.println("A or B");
delay(500);
char a = userinput();
delay(500);
while(a== 'A'){
Serial.println("Type Your Starting ID Number...");
while(1 ){
while (Serial.available()==false);
char e = Serial.read();
if(isdigit(e)==false) break;
startid = (startid*10)+(e - 48);
}
if(startid<=endid){
for(pageid=startid; pageid<=endid; pageid++)
{
Serial.print("Your Biometric ID # is ");
Serial.println(pageid);
delay(2000);
fingerenrollment(pageid);
delay(2000);
if(pageid == endid){
Serial.println("......Memory Is Full....");
while(1);
}
}
}
else{
Serial.println("Wrong Entry.......Please Reset Your Device.....");
while(1);
}
}
////// user
while(a=='B'){
lcd.print("WELCOME TO iPoll");
delay(2000);
lcd.clear();
lcd.print("Place Your Thumb");
delay(2000);
lcd.clear();
tempid = '\0';
Serial.println("Place your Thumb For Authentication");
delay(500);
while(true){
ID = fingerauthentication();
delay(500);
if(tempid != '\0') break;
}
delay(100);
resp = userinput();
delay(100);
lcd.clear();
datatrans(ID, resp);
}
}
If you need any more help, I am here. Just comment.

You seem to be stuck in an infinite while loop. Try changing while(a=='A') and while(a=='B') to if(a=='A') and if(a=='B'). The void loop() method in Arduino automatically acts like an infinite while loop, looping through the code within it forever.

while (a == 'A') loop is never ending because you never change the value of a. You need some a = something; somewhere in your code, or do what #Dan12-16 said. The same applies to 'B'.
And a couple of tips to make your code easier to read (in my opinion). Instead of using if (condition == false), you could use if (!condition). Choose while (1) or while (true), but don't mix them (I would choose the second one).

Related

How to store & call multiple letters in arduino?

Im new to programming, and I'm trying to make a program that adjusts LEDs according to the serial input.
#define Bathroom 13 //LED connected to pin13 named bathroom
#define Livingroom 9 //LED connected to pin9 named livingroom
char *myStrings[] = {"bathdim","bathbright","livingdim","livingbright","beddim","bedbright"};
void setup(){
pinMode(Bathroom, OUTPUT);
pinMode(Livingroom, OUTPUT);
Serial.begin(9600);
}
void loop() {
if(Serial.read() == *myStrings[0]){
Serial.println(*myStrings[0]); // prints "bathdim" on the serial monitor
digitalWrite(Bathroom,0); // turns lights off
delay(100);
}
if(Serial.read() == *myStrings[1]){ // prints "bathbright" on the serial monitor
Serial.println(*myStrings[1]); // turns lights on
digitalWrite(Bathroom,1);
delay(100);
}
if(Serial.read() == *myStrings[2]){
Serial.println(*myStrings[2]);
digitalWrite(Livingroom,0);
delay(100);
}
if(Serial.read() == *myStrings[3]){
Serial.println(*myStrings[3]);
digitalWrite(Livingroom,1);
delay(100);
}
}
When running the code, I typed in "bathbright" which should have turned the lights on, but I didn't work, and the Serial.println(*myStrings[1]) only prints letter "b", not "bathbright"
can anyone help?
EDIT
ok, I removed the * and now the code is as follows:
#define Bathroom 13 //LED connected to pin13 named bathroom
#define Livingroom 9 //LED connected to pin9 named livingroom
char *myStrings[] = {"bathdim","bathbright","livingdim","livingbright","beddim","bedbright"};
void setup(){
pinMode(Bathroom, OUTPUT);
pinMode(Livingroom, OUTPUT);
Serial.begin(9600);
}
void loop() {
if(Serial.read() == *myStrings[0]){
Serial.println(myStrings[0]);
digitalWrite(Bathroom,0);
delay(100);
}
if(Serial.read() == *myStrings[1]){
Serial.println(myStrings[1]);
digitalWrite(Bathroom,1);
delay(100);
}
if(Serial.read() == *myStrings[2]){
Serial.println(myStrings[2]);
digitalWrite(Livingroom,0);
delay(100);
}
if(Serial.read() == *myStrings[3]){
Serial.println(myStrings[3]);
digitalWrite(Livingroom,1);
delay(100);
}
}
The code works well initially but after a few inputs of bathbright and bathdim, he serial print does not print the correct words and the LEDs does not always respond...
FINAL CODE:
#define Bathroom 13 //LED connected to pin13 named bathroom
#define Livingroom 9 //LED connected to pin9 named livingroom
void setup(){
Serial.begin(9600);
pinMode(Bathroom, OUTPUT);
pinMode(Livingroom, OUTPUT);
}
void loop(){
String str = Serial.readString();
if(str.indexOf("bathdim") > -1){
Serial.println("dimming bathroom");
digitalWrite(Bathroom,0);
}
if(str.indexOf("bathbright") > -1){
Serial.println("lighting up bathroom");
digitalWrite(Bathroom,1);
}
if(str.indexOf("livingdim") > -1){
Serial.println("dimming Livingroom");
digitalWrite(Livingroom,0);
}
if(str.indexOf("livingbright") > -1){
Serial.println("lighting up Livingroom");
digitalWrite(Livingroom,1);
}
}
Just remove * ! because *string refers to the first case in the string ! so *string[0] refers to the first letter in the first case in the string array !
Serial.read() will only read the first byte. You'll have to read the whole string in a loop (and a large enough buffer) and use a compare function to compare the strings.
As an alternative for testing you could use a single byte code - for example 'a', 'b', 'c' and 'd'.
To print the second string in the aray, you can use Serial.println(myStrings[1]).
Here is an example using single chars:
void loop() {
if (Serial.available()) {
int value = Serial.read();
switch (value) {
case 'a':
digitalWrite(Bathroom, 0);
break;
case 'b':
digitalWrite(Bathroom, 1);
break;
case 'c':
digitalWrite(Livingroom, 0);
break;
case 'd':
digitalWrite(Livingroom, 1);
break;
default :
break;
}
if (value >= 'a') { // avoid delaying on newlines
delay(100);
}
}
}
*(myStrings[0]) will get the first (char *) in the array, which points to starting memory location containing bathdim, then you dereference that, using the * which prints the first character, so you get letter b.
Just remove the dereferencing, remove that *
Edit- saw your updated question, the star is not gone, but anyway try using Serial.readString() to read in a string, you are reading in 1 byte at a time

Trouble Reading from Serial.readstring() arduino UNO

The objective is to enter "on" and "off" in COM port and switch the Pin 13. No matter what I do. It won't switch on or off. Need help. I tried to see if the string I entered is "on". It prints "on" but when I check for the result it shows its different. What is wrong?
String SData;
String SData1;
void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
pinMode(13,OUTPUT);
digitalWrite(13,HIGH);
delay(5000);
digitalWrite(13,LOW);
delay(1000);
}
void loop() {
// put your main code here, to run repeatedly:
while(Serial.available()==0)
{
}
SData=Serial.readString();
SData1="on";
if(SData==SData1)
Serial.print("Same");
else
{
Serial.print("Different");
// Serial.print(SerialData-SerialData1);
Serial.print(".");
}
if(SData=="on")
{
digitalWrite(13,HIGH);
Serial.println("LED ON");
delay(2000);
}
Serial.println(SData);
if(SData=="off")
{
digitalWrite(13,LOW);
Serial.println("LED OFF");
delay(2000);
}
SData="";
}

trying to work with strings and serial port on arduino, my sketch skips characters for some reason

I've been trying to achieve serial communication between my arduino-based project and my pc ,i need to send commands to arduino over serial and use "if and else" to call desired function (in parseMessage() function).
I can't use delay() since I'm using interrupts for multiplexing and bit-angle modulation so i had to do serial communication another way around, this is closest I've got to succeess but still I'm getting character skips and unstability in general. and as you know coding is all great except for when you don't know what's wrong with your code, so help me please gods of the internet! ;)
The reason I'm using '#' as end of the string declearation is that I can't be sure that all characters of my command sent to arduino is there when Serial.read() asks for it, there might be more on the way and since atmega328 is faster than serial port Serial.available() might actually return -1 in middle of transmission.
ps : oh, and I can't use String class, It's very expensive, this atmega328 is already sweating under 8x8 RGBLED multiplexing and 4bit-angle modulation and he is gonna have to do even more in future.
ps : and I'm still learning English so pardon me if there is something wrong with the grammer I'm using.
void setup() {
Serial.begin(9600);
}
bool dataRTP = false; // data ready to parse
void loop() {
readSerial();
}
char message[64];
int index = 0;
void readSerial() {
if (Serial.available() > 0)
while (Serial.available() > 0)
if (Serial.peek() != '#') // i'm using '#' as end of string declearation.
message[index++] = Serial.read();
else {
message[index++] = '\n';
dataRTP = true;
break;
}
while (Serial.read() != -1) {} // flushing any possible characters off of
if (dataRTP) // UARTS buffer.
parseMessage();
}
void parseMessage() { // just testing here, actual code would be like :
Serial.print(message); // if (!strcmp(message, "this expression"))
index = 0; // callthisfunction();
dataRTP = false; // else ... etc
}
Just managed to fix this code, seems flushing data off of serial UART wasn't a good idea after all. It's all solved. Here's how code looks now:
void setup() {
Serial.begin(9600);
}
bool dataRTP = false;
void loop() {
readSerial();
}
char message[64];
int index = 0;
void readSerial() {
if (Serial.available() > 0)
while (Serial.available() > 0)
if (Serial.peek() == '#') {
message[index++] = Serial.read();
message[index++] = '\0';
dataRTP = true;
break;
}
else
message[index++] = Serial.read();
if (dataRTP)
parseMessage();
}
void parseMessage() {
Serial.println(message);
index = 0;
dataRTP = false;
}

Sketch that responds to certain commands, how is it done?

Alright I have a half complete Arduino sketch at the moment. Basically the sketch below will blink an LED on a kegboard-mini shield if a string of chars equals *{blink_Flow_A}* However the LED only blinks once with the current sketch loaded on the Arduino. I will like the Arduino to blink repeatedly until the "stop" command is sent to the Arduino. I would eventually like to open a valve, keep it open until the valve receives to the close command then close the valve. The sketch looks like the following,
/*
* kegboard-serial-simple-blink07
* This code is public domain
*
* This sketch sends a receives a multibyte String from the iPhone
* and performs functions on it.
*
* Examples:
* http://arduino.cc/en/Tutorial/SerialEvent
* http://arduino.cc/en/Serial/read
*/
// global variables should be identified with _
// flow_A LED
int led = 4;
// relay_A
const int RELAY_A = A0;
// variables from sketch example
String inputString = ""; // a string to hold incoming data
boolean stringComplete = false; // whether the string is complete
void setup() {
Serial.begin(2400); // open serial port, sets data rate to 2400bps
Serial.println("Power on test");
inputString.reserve(200);
pinMode(RELAY_A, OUTPUT);
}
void open_valve() {
digitalWrite(RELAY_A, HIGH); // turn RELAY_A on
}
void close_valve() {
digitalWrite(RELAY_A, LOW); // turn RELAY_A off
}
void flow_A_blink() {
digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for one second
digitalWrite(led, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}
void flow_A_blink_stop() {
digitalWrite(led, LOW);
}
void loop() {
// print the string when newline arrives:
if (stringComplete) {
Serial.println(inputString);
// clear the string:
inputString = "";
stringComplete = false;
}
if (inputString == "{blink_Flow_A}") {
flow_A_blink();
}
}
//SerialEvent occurs whenever a new data comes in the
//hardware serial RX. This routine is run between each
//time loop() runs, so using delay inside loop can delay
//response. Multiple bytes of data may be available.
void serialEvent() {
while(Serial.available()) {
// get the new byte:
char inChar = (char)Serial.read();
// add it to the inputString:
inputString += inChar;
// if the incoming character is a newline, set a flag
// so the main loop can do something about it:
if (inChar == '\n') {
stringComplete = true;
}
}
}
If it makes any difference someone on IRC told me to research state machines scratches head
To blink a Led without blocking the program, i suggest you use Timer (and the TimerOne library). I make a quick sample code :
#include "TimerOne.h" //Include the librart, follow the previous link to download and install.
int LED = 4;
const int RELAY_A = A0;
boolean ledOn;
void setup()
{
pinMode(LED, OUTPUT)
Timer1.initialise(500000) // Initialise timer1 with a 1/2 second (500000µs) period
ledOn = false;
}
void blinkCallback() // Callback function call every 1/2 second when attached to the timer
{
if(ledOn){
digitalWrite(LED,LOW);
ledOn = false;
}
else{
digitalWrite(LED,HIGH);
ledOn = true;
}
}
void open_valve() {
digitalWrite(RELAY_A, HIGH); // turn RELAY_A on
}
void close_valve() {
digitalWrite(RELAY_A, LOW); // turn RELAY_A off
}
void serialEvent() {
while(Serial.available()) {
char inChar = (char)Serial.read();
inputString += inChar;
if (inChar == '\n') {
stringComplete = true;
}
}
}
void loop()
{
// print the string when newline arrives:
if (stringComplete) {
Serial.println(inputString);
// clear the string:
inputString = "";
stringComplete = false;
}
if (inputString == "{blink_Flow_A}") {
Timer1.attachInterupt(blinkCallback); //Start blinking
}
if (inputString == "{stop}") {
Timer1.detachInterrupt(); //Stop blinking
}
if (inputString == "{open_valve}") {
open_valve();
}
if (inputString == "{close_valve}") {
close_valve();
}
}
Note :
Consider putting the tag 'c' or 'java' to have syntax highlighting on the code.
A state machine (at it's simplest - it can be lots more complicated) can be just a set of conditional statements (if/else or switch/case) where you do certain behaviors based on the state of a variable, and also change that variable state. So it can be thought of as a way of handling or progressing through a series of conditions.
So you have the state of your LED/valve - it is either blinking (open) or not blinking (closed). In pseudo code here:
boolean LED_state = false; //init to false/closed
void loop(){
if (checkForCorrectCommand() == true){ //
if (LED_State == false){
open_valve();
LED_State = true;
} else {
close_valve();
LED_State = false;
}
}
}
The blinking LED part should be easy to implement if you get the gist of the code above. The checkForCorrectCommand() bit is a function you write for checking whatever your input is - key, serial, button, etc. It should return a boolean.
Perhaps something like the 'blink without delay' example in the IDE. You check the time and decide to when and how to change the LED/Digital out.
// Variables will change:
int ledState = LOW; // ledState used to set the LED
long previousMillis = 0; // will store last time LED was updated
// the follow variables is a long because the time, measured in miliseconds,
// will quickly become a bigger number than can be stored in an int.
long interval = 1000; // interval at which to blink (milliseconds)
void setup(){
// Your stuff here
}
void loop()
{
// Your stuff here.
// check to see if it's time to blink the LED; that is, if the
// difference between the current time and last time you blinked
// the LED is bigger than the interval at which you want to
// blink the LED.
unsigned long currentMillis = millis();
if(currentMillis - previousMillis > interval) {
// save the last time you blinked the LED
previousMillis = currentMillis;
// if the LED is off turn it on and vice-versa:
if (ledState == LOW)
ledState = HIGH;
else
ledState = LOW;
// set the LED with the ledState of the variable:
digitalWrite(ledPin, ledState);
}
}
Let me offer a suggested sketch with a few changes. Bastyen's idea of using a timer is quite good and makes the code much easier. The approach I would suggest is to have the timer pop forever at a fixed interval (100 milliseconds in my sketch). If the LED should not be blinking it stays off. If the LED should be blinking, it switches from off to on or vice versa each time the timer goes off.
#include "TimerOne.h"
/*
* kegboard-serial-simple-blink07
* This code is public domain
*
* This sketch sends a receives a multibyte String from the iPhone
* and performs functions on it.
*
* Examples:
* http://arduino.cc/en/Tutorial/SerialEvent
* http://arduino.cc/en/Serial/read
*/
// global variables should be identified with _
// flow_A LED
int led = 4;
// relay_A
const int RELAY_A = A0;
// variables from sketch example
String inputString = ""; // a string to hold incoming data
boolean stringComplete = false; // whether the string is complete
boolean shouldBeBlinking = false;
boolean ledOn = false;
void setup() {
Serial.begin(9600); // open serial port, sets data rate to 2400bps
Serial.println("Power on test");
inputString.reserve(200);
pinMode(RELAY_A, OUTPUT);
pinMode(led, OUTPUT);
digitalWrite(led, LOW);
Timer1.initialize(100000);
Timer1.attachInterrupt(timer1Callback);
}
void loop() {
if (!stringComplete)
return;
if (inputString == "{blink_Flow_A}")
flow_A_blink_start();
if (inputString == "{blink_Flow_B}")
flow_A_blink_stop();
inputString = "";
stringComplete = false;
}
void timer1Callback() {
/* If we are not in blinking mode, just make sure the LED is off */
if (!shouldBeBlinking) {
digitalWrite(led, LOW);
ledOn = false;
return;
}
/* Since we are in blinking mode, check the state of the LED. Turn
it off if it is on and vice versa. */
ledOn = (ledOn) ? false : true;
digitalWrite(led, ledOn);
}
void flow_A_blink_start() {
shouldBeBlinking = true;
open_valve();
}
void flow_A_blink_stop() {
shouldBeBlinking = false;
close_valve();
}
void close_valve() {
digitalWrite(RELAY_A, LOW); // turn RELAY_A off
}
void open_valve() {
digitalWrite(RELAY_A, HIGH); // turn RELAY_A on
}
//SerialEvent occurs whenever a new data comes in the
//hardware serial RX. This routine is run between each
//time loop() runs, so using delay inside loop can delay
//response. Multiple bytes of data may be available.
void serialEvent() {
if (stringComplete)
return;
while(Serial.available()) {
// get the new byte:
char inChar = (char)Serial.read();
// add it to the inputString unless it is a newline
if (inChar != '\n')
inputString += inChar;
// if the incoming character is a newline, set a flag
// so the main loop can do something about it:
else {
stringComplete = true;
}
}
}
A few notes:
The setup function establishes the timer with a 100 millisecond interval and attaches the callback routine. Based on my testing, this only needs to be done once.
The main loop just ignores everything unless an input string is complete. If an input string is ready, then the input string is checked for two known values and the appropriate steps are taken. The input string is then discarded.
The timer callback routine forces the LED off, if we are not in blinking mode. Otherwise, it just toggles the state of the LED.
The flow on and flow off routines set the blinking state as need be and control the valve
The serial event routine has two changes. First, input is ignored (and kept in the buffer) if an input string is already complete. This will preserve commands that are being sent to the Arduino while the current command is being processed. Second, the newline character is not added to the input string. This makes checking the input string slightly easier.

How to break an infinite for(;;) loop in C?

I have a vital infinite for loop that allows a sensor to keep updating its values. However I would like to break that for loop when another sensor brings in new values. How can I switch from one infinite for loop to another?
Current code:
for(;;){
SON_Start();
// Wait 65ms for max range time
delay10ms(7);
// Read Range
i = SON_Read(SON_ADDRESSES[sonarReading]);
// pause
delayMs(100);
if(i<15)
drive(200, RadCW);
}
What I would like to add:
If Sensor2 returns a reading (e.g. Sensor2 > 20), then I want to break the loop and goto another infinite for loop to begin a new function.
If you are looking for "switching between 2 infinite loops" it could be "wrapped" by third loop and this "switching" could be done by simple break.
But since you want your program to stop some day, this loop could be placed within the function and you could use return; for ending it:
void myMagicLoop()
{
for(;;)
{
for(;;)
{
if ( I should stop )
return;
if ( I should switch to second loop )
break;
}
for(;;)
{
if ( I should stop )
return;
if ( I should switch back to first loop)
break;
}
}
}
And somewhere you just call:
myMagicLoop();
Hope this helps.
This will switch between loop A and loop B.
for (;;)
{
// Loop A
for (;;)
{
if WANT_TO_SWITCH
{
break;
}
}
// Loop B
for (;;)
{
if WANT_TO_SWITCH
{
break;
}
}
}
You use break; to break a loop and pass control beyond its closing brace. For example
for(;;) {
if( whatever ) {
break;
}
}
//break gets you here
Alternatively you could consider rewriting this with an event-driven approach. This will of course depend on what your hardware is capable of, but at the very least you should be able to produce some timer events.
Then the code would go something like this:
static volatile bool sensor_1_ready;
static volatile bool sensor_2_ready;
for(;;)
{
switch(state_machine)
{
case READING_SENSOR_1:
if(sensor_2_ready)
{
state_machine = READING_SENSOR_2;
}
else if(sensor_1_ready)
{
process sensor 1
}
break;
case READING_SENSOR_2:
if(!sensor_2_ready && some_timeout_etc)
{
state_machine = READING_SENSOR_1;
}
else if(sensor_2_ready)
{
process sensor 2
}
break;
}
}
void callback_sensor_1 (void) // some sort of interrupt or callback function
{
sensor_1_ready = true;
}
void callback_sensor_2 (void) // some sort of interrupt or callback function
{
sensor_2_ready = true;
}
(Before commenting on the volatile variables, please note that volatile is there to prevent dangerous compiler optimizations and not to serve as some mutex guard/atomic access/memory barrier etc.)
The "break" command should do what you need?
The best way to do that is to change the for statement to something like:
for (; Sensor2 <= 20;) {
...
Alternatively you can change it from a for to a while statement:
while (Sensor2 <= 20) {
...
If that doesn't suite your needs you can always use a break instead.
Another option could be to use signals (SIGUSR1,SIGUSR2) to switch from one loop to another.
Something of this sort:
void sensor2(int signum)
{
for (; ;)
...
/* Need to process sensor 1 now */
kill(pid, SIGUSR1);
}
void sensor1(int signum)
{
for (; ;)
...
/* Need to process sensor 2 now */
kill(pid, SIGUSR2);
}
int main()
{
/* register the signal handlers */
signal(SIGUSR1, sensor1);
signal(SIGUSR2, sensor2);
...
}

Resources