Hi Guys,
i am hoping someone can help me Repeating only a specific condition during a void loop. Basically, i have a set of conditiond within the
void loop sections, and i want to repeat the bottom part the void loop a specific number of times. how would i go about that ?
not much to go on there,
While( your condition == true ) // loop until you conditions become true
{
Act on it
}
please post your code or at least what you have so far,
might want to have a look here http://arduino.cc/forum/index.php/topic,97455.0.html
Not much information to go on here but the usual way to repeat something x times is the 'for' command http://arduino.cc/en/Reference/For
Funky_Arduino:
Hi Guys,i am hoping someone can help me Repeating only a specific condition during a void loop. Basically, i have a set of conditiond within the
void loop sections, and i want to repeat the bottom part the void loop a specific number of times. how would i go about that ?
Set up a variable, a global byte (or static byte inside loop()) and change the value however you want the condition to run next time through loop.
If you want something to run 3 times then you can make the variable = 3 in setup() then each time through loop() check if it's > 0. If so then run the specific code and subtract 1 from the variable. 3-2-1, it runs, 0 it doesn't run and the variable doesn't change (unless you code for that on say, a button press).
All that without -another- set of braces and indents to go with a for-next and you get code that's easier to modify.
hi all,
thanks for your replies. I have attached the code.
Essentially i want to repeat the second for loop 3 types. The first for loop will run to generate 60 pwm values, but i dont want it do do anything more then that.
Im not quite sure on how to implement the solutions you guys have suggested in the previous posts as i am fairly new to arduino and programming in general.
Assistance is appreciated
void_example.ino (390 Bytes)
Had a look at your code, im not being funny but you seem confused.
void loop() {
for (k=0;k<counter;k++){
pwm_count= pwm_count_old[k];
analogWrite(pwm_pin,pwm_count);}
// Repeat for 60 points before it moves onto the next function
for {count=0;counter;count++){
scaling= Output/10 ;
pwm_new=scaling* (pwm_default[count]);
analogWrite(pwm_pin,pwm_default); }
delay (2000); // delay after each pwm value
if count>60;
delay(10000);
}
}
}
heres how to perform your first loop
int pwm_pin = 3; // pwm output pin or whichever pin you choose
void setup()
{
}
void loop()
{
for (int pwm_count=0; pwm_count<60; pwm_count++) // Repeat for 60 values
{
analogWrite(pwm_pin,pwm_count);
}
}
if you only want perform an action 3 times just create a new for loop with a value of 3
what is it exactly you wish to do?
you reference scaling / 10, i am not sure what your doing, to break the value of 60 in to 6 steps do this
for (int pwm_count=0; pwm_count<60; pwm_count+=10)
Hi,
i think i should have made it more clearer.. i only pasted the void loop of my code. this line pwm_count= pwm_count_old[k]; is me generating a new set of pwm values by . I have uploaded the entire code now. It sound be more clear what i am trying to achieve, and what i am asking which is repeating the second for loop 3 times. again i am very new at programming and every help is so greatly appreciated.
Thanks
void_example.ino (1.65 KB)
Im reading through your code now, there are a few errors
two things i find useful when writing code are
Serial.println(pwm_count_old[index]); // debug to serial monitor
so you can see whats happening and also
while(1);
when you don't want void loop() to continously repeat, also useful for debugging
Now there's a PIC solution if I ever saw one. Run a closed loop inside a closed loop to prevent the second one from running!
LOL @ GoForSmoke, while(1); is usefull for debugging when i dont want the whole procedure to run, besides PIC's don't use stupid void loop(){} anyway.
Funky_Arduino this is as much as i can get from your description, you have 61 numbers in the 2 arrays and there was a couple of other syntax errors but this code is working as close as i can get to your original description
int x[60]={ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
51, 52, 53, 54, 55, 56, 57, 58, 59, 60};
int y[60]={0.00,0.05,0.10,0.16,0.21,0.26,0.31,0.36,0.41,0.45,
0.50,0.54,0.59,0.63,0.67,0.71,0.74,0.78,0.81,0.84,
0.87,0.89,0.91,0.93,0.95,0.97,0.98,0.99,0.99,1.00,
1.00,1.00,0.99,0.99,0.98,0.97,0.95,0.93,0.91,0.89,
0.87,0.84,0.81,0.78,0.74,0.71,0.67,0.63,0.59,0.54,
0.50,0.45,0.41,0.36,0.31,0.26,0.21,0.16,0.10,0.05}; // too many numbers here ,0.00};
int pwm_default[60]={ 0, 13, 27, 40, 53, 66, 79, 92,104,116,
128,139,150,161,171,181,190,199,207,215,
222,228,234,239,243,247,250,253,255,256,
256,256,255,253,250,247,243,239,234,228,
222,215,207,199,190,181,171,161,150,139,
128,116,104, 92, 79, 66, 53, 40, 27, 13}; // too many numbers here ,0};
int pwm_count_old[60]={ 5, 9,14,19,23,28,32,36,41,45,
49,53,56,60,63,67,70,72,75,78,
80,82,84,85,87,88,88,89,89,90,
89,89,88,88,87,85,84,82,80,78,
75,72,70,67,63,60,56,53,49,45,
41,36,32,28,23,19,14, 9, 5, 0};
String inString = ""; // does nothing here
int pwm_pin=6;
float output=9;
float pwm_new;
int scalling = 10;
void setup()
{
Serial.begin(9600);
}
void loop()
{
for (int index=0; index<60; index++) // Repeat for 60 points before it moves onto the next function
{
Serial.println(pwm_count_old[index]); // Debug to serial
analogWrite(pwm_pin,pwm_count_old[index]); // i would like to run through each of the pwm_count _old vector values and analog write each value
delay(2000);
}
for (int do_loop=0; do_loop<3; do_loop++)
{
for (int index=0; index<60; index++)
{
pwm_new=(output / scalling) * pwm_default[index]; //i would like to run through each of the pwm_default values multiplied by by scaling
Serial.println(pwm_new); // Debug to serial
analogWrite(pwm_pin,pwm_new);
delay(2000);
}
}
delay(10000);
}
It's simpler if you use what's there as intended.
void loop() // that has to be there anyway
{
if (end_condition) return; // better/more complete would be put the AVR into sleep mode
BTW, all elements of int y[] you have there will == 0. Integers round off float constants.
I agree there are better ways for doing it, but if you look at the original post there's not alot to go on
Funky, this is an example of doing what you asked about. You still need to apply the principle to your code.
This is a modified version of BlinkWithoutDelay made to limit the number of blinks.
It is tested and working on my UNO running IDE 0022, I think it should work on IDE 1.0.
Wherever I added code I made a comment starting with the word MODIFIED.
Be sure to read the comments in those parts, especially the PLEASE NOTE part.
See how with very little added code you can reach into a program and alter the behavior. If you add other code that changes blinkCounter (say on a button press or serial input), you don't need to mess with nesting loops or any of that. Just changing the variable controls the action.
/* MODIFIED 8/25/12 to only blink 10 times
Blink without Delay
Turns on and off a light emitting diode(LED) connected to a digital
pin, without using the delay() function. This means that other code
can run at the same time without being interrupted by the LED code.
The circuit:
* LED attached from pin 13 to ground.
* Note: on most Arduinos, there is already an LED on the board
that's attached to pin 13, so no hardware is needed for this example.
created 2005
by David A. Mellis
modified 8 Feb 2010
by Paul Stoffregen
This example code is in the public domain.
http://www.arduino.cc/en/Tutorial/BlinkWithoutDelay
*/
// constants won't change. Used here to
// set pin numbers:
const int ledPin = 13; // the number of the LED pin
// 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)
// MODIFIED 8/25/12 -- adding a variable to limit blinks
byte blinkCounter;
void setup() {
// set the digital pin as output:
pinMode(ledPin, OUTPUT);
// MODIFIED 8/25/12 -- setting the number of blinks to do
blinkCounter = 10;
}
void loop()
{
// here is where you'd put code that needs to be running all the time.
// MODIFIED 8/25/12 to limit the number of blinks
// PLEASE NOTE THAT code placed above this inside loop() will still run
if ( blinkCounter < 1 ) return; // press the reset button to blink again
// 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;
// MODIFIED 8/25/12 -- it blinked ON now OFF so reduce the count
blinkCounter--;
}
// set the LED with the ledState of the variable:
digitalWrite(ledPin, ledState);
}
}