Thread: Need logic help

Originally Posted by Norm

Sounds like you need a boolean variable that says that count is either to be incremented or to be decremented.
And then a test for when the value of count has hit one of the boundaries.

Please edit your post and wrap your code with code tags:

[code]
**YOUR CODE GOES HERE**
[/code]

to get highlighting and preserve formatting.

I changed the format, if I were to use a boolean variable would it affect it where once I've met the condition where count == 1 that the count down would start and count up would be false where since im counting down count is no longer 1 and therefore count up would be true

Originally Posted by Norm

You would use the value in the boolean to decide if count was to be incremented or to be decremented.

For example

if(incrementCount)
   count += 1;
else
   count -= 1;

The code would change the value in incrementCount when the boundary was met:

if(incrementCount && count >= boundary)
   incrementCount = false;   // change so the value is decremented

There would be similar logic for the other conditions.

Just to make sure the incrementCount boolean is true so it counts up and once it reaches the boundary in this case 1 it becomes false therfore in the the second if, increment Count is no longer true so it goes to the else and starts decrementing

Originally Posted by Norm

Yes, that sounds about right. Now try writing the code for that part of it.

 
package gettingstarted;
 
 
 
 
//Add Phidgets Library | You added a file called phidget22 when configuring your project. Import gives you access to the Phidgets library code inside that file. 
import com.phidget22.*;
 
 
public class LEDBrightness {
 
       //Handle Exceptions 
    public static void main(String[] args) throws Exception{
 
         double count=0;   
         boolean incrementCount = true;
 
        //Create 
        DigitalOutput redLED = new DigitalOutput();
 
        //Address 
        redLED.setHubPort(1);
        redLED.setIsHubPortDevice(true);
 
        //Open 
        redLED.open(1000);
 
        //Use your Phidgets with Duty Cycle 
 
 
    while (true) {
 
        if (incrementCount && count <=1) 
              count+=.1;
          else
              count-=.1;
        incrementCount=false;
 
 
          redLED.setDutyCycle(count);
          Thread.sleep(1000);
 
    }
 
    }
 
 
    }

So i tried implementing the logic you said, where I have the conditional where if count was less than one incrementCount would be true and that once count was => 1 it would go to the else and increment count would be false and would skip the if and go to the else and start decrementing but when i run the code i get one increment of .1 then it goes out other the boundary which is 0-1

Originally Posted by Norm

The variable: incrementCount is set to false the first time through the loop. It should only be set false when the count has reached the boundary.

The if statements need to be more complicated so that incrementCount count is only set false when the value of count has reached the boundary.
It needs to stay true as the value is incremented until it reaches the boundary.

Before writing any more code, write some pseudo code that describes the steps the program needs to take to solve the problem.

Add a few more statements to the above.

package gettingstarted;
 
 
 
 
//Add Phidgets Library | You added a file called phidget22 when configuring your project. Import gives you access to the Phidgets library code inside that file. 
import com.phidget22.*;
 
 
public class LEDBrightness {
 
       //Handle Exceptions 
    public static void main(String[] args) throws Exception{
 
         double count=0;  // count starts at zero 
         boolean incrementCount =true;
 
        //Create 
        DigitalOutput redLED = new DigitalOutput();
 
        //Address 
        redLED.setHubPort(1);
        redLED.setIsHubPortDevice(true);
 
        //Open 
        redLED.open(1000);
 
        //Use your Phidgets with Duty Cycle 
 
 
    while (true) {
 
        if (incrementCount==true) // if incrementCount is true which it starts as true count will incremetn by .1
            count+=.1;
        else 
            count-=.1;  // if incrementCount is not true is will decrement the count by.1
 
         if(incrementCount && count>=1);  // conditional where if incrementCount is true and the count has reached the boundary increment count will be false 
                                          // when the loop iterates again and checks the first condiotional incrementCount will be false and it 
                                          //will go to the else and start decrementing 
            incrementCount=false;
 
 
 
 
 
 
 
          redLED.setDutyCycle(count);
          Thread.sleep(1000);
 
    }
 
    }
 
 
    }

I changed the if statements and Im confused as to why it is being set as false when it iterates because to my understanding it should only be set to false when incrementCount is true and the boundary has been met where count is >=1; but since the error comes within seconds of running i can see that it becomes false too fast and I'm unsure why

Originally Posted by Norm

You need to look at the compiler's warning statements when you compile the code.
Here is the warning I get when I compile your code:

LEDBrightness.java:35: warning: [empty] empty statement after if
         if(incrementCount && count>=1);  // conditional where if incrementCount is true and the count has reached the boundary increment count will be false 
                                       ^

The ; ends the if statement. Any statements after that are NOT inside of the if. Remove the ;

Also you should always use {} to enclose code that is controlled by an if statement. I was lazy and didn't. I have fixed it now.

 
package gettingstarted;
 
 
 
 
//Add Phidgets Library | You added a file called phidget22 when configuring your project. Import gives you access to the Phidgets library code inside that file. 
import com.phidget22.*;
 
 
public class LEDBrightness {
 
       //Handle Exceptions 
    public static void main(String[] args) throws Exception{
 
         double count=0;  // count starts at zero 
         boolean incrementCount =true;
 
        //Create 
        DigitalOutput redLED = new DigitalOutput();
 
        //Address 
        redLED.setHubPort(1);
        redLED.setIsHubPortDevice(true);
 
        //Open 
        redLED.open(1000);
 
        //Use your Phidgets with Duty Cycle 
 
 
    while (true) {
 
        if (incrementCount==true) { // if incrementCount is true which it starts as true count will incremetn by .1
            count+=.1;
        }else 
        {
            count-=.1;  // if incrementCount is not true is will decrement the count by.1
 
        }
        if(incrementCount && count>=1){
                                        // conditional where if incrementCount is true and the count has reached the boundary increment count will be false 
                                     //will go to the else and start decrementing 
            incrementCount=false;
        }
 
 
 
 
 
 
          redLED.setDutyCycle(count);
          Thread.sleep(1000);
 
    }
 
    }
 
 
    }

the warning I get is

Exception in thread "main" PhidgetException 0x15 (Invalid Argument)
Value must be in range: 0.000000 - 1.000000.
at com.phidget22.DigitalOutputBase.setDutyCycle(Nativ e Method)

I removed the ";" so that the incrementCount=false statement could be reached, but I can tell because I have an output device the shows the count going up but never going down and count is going past 1 and the conditional is not making incrementCount false the error message was after I made the changes but it runs until count is incremented past its boundary

Originally Posted by Norm

What value is in count when the exception happens?

For debugging, add some print statements that print the value of count and incrementCount as the loop iterates.

0.1
0.2
0.30000000000000004
0.4
0.5
0.6
0.7
0.7999999999999999
0.8999999999999999
0.9999999999999999
1.0999999999999999
Exception in thread "main" PhidgetException 0x15 (Invalid Argument)
Value must be in range: 0.000000 - 1.000000.
at com.phidget22.DigitalOutputBase.setDutyCycle(Nativ e Method)

would this be a code problem or IDE problem

Originally Posted by Norm

So it looks like the code increments count past the value of 1 before testing if count's value is greater than 1.

You need to notice how floating point numbers work. The value of count is never 1.0000
It goes from 0.9999999999999999 to 1.0999999999999999
so instead of testing count >= 1, test for >= 0.9

So technically the code is correct because the increment is .1 but for avoiding the error I should put .9. And if I want it to end after decrementing would how would i do that with a boolean or do i not need a boolean

Originally Posted by Norm

Use an if statement to prevent the value from going below the lower boundary.
You should not need a new boolean. The value of incrementCount would be false while count is being decremented.


There is a problem representing values of floating point numbers on a computer. There is not an exact fit so there is some rounding done.
For a technical discussion: http://docs.oracle.com/cd/E19957-01/..._goldberg.html

since

count-=.1

is what will be executing every time would the if statement be after the conditional where i need to make it so that its

if (count == 0) { 
// i want count to stop decrementing and stay at zero
}

the thing im a little confused with is since the increment is based on if incrementCount is true or false how does that change when count == 0 and i need it to stop

Originally Posted by Norm

How about something like this:
if count not at boundary
then decrement count
else leave count where it is - stop changing its value

would this require any change in my current code or would i just add this to what i have

if (count!=0) {
incrementCount=false;
} else {
count=0;
 
}

Originally Posted by Norm

Remember that floating point numbers are not always exactly equal to integer values.

That code doesn't do what I suggested in my last post.

That code is like this:
if count != 0 then do this...
else (count is 0) set count to 0??? but it is already 0

What happens when you try that code from post#19 in your program?

ye the code I suggested gives an error where it counts below 0

 
package gettingstarted;
 
 
 
 
//Add Phidgets Library | You added a file called phidget22 when configuring your project. Import gives you access to the Phidgets library code inside that file. 
import com.phidget22.*;
 
 
public class LEDBrightness {
 
       //Handle Exceptions 
    public static void main(String[] args) throws Exception{
 
         double count=0;  // count starts at zero 
         boolean incrementCount =true;
 
        //Create 
        DigitalOutput redLED = new DigitalOutput();
 
        //Address 
        redLED.setHubPort(1);
        redLED.setIsHubPortDevice(true);
 
        //Open 
        redLED.open(1000);
 
        //Use your Phidgets with Duty Cycle 
 
 
    while (true) {
 
        if (incrementCount==true) { // if incrementCount is true which it starts as true count will incremetn by .1
            count+=.1;
        }else{
 
            count-=.1;  // if incrementCount is not true is will decrement the count by.1
 
        }
        if(incrementCount && count>=1){
                                        // conditional where if incrementCount is true and the count has reached the boundary increment count will be false 
                                     //will go to the else and start decrementing 
            incrementCount=false;
        }
 
        System.out.println(count);
 
            if (count!=0) {
            incrementCount=false;
        } else {
            count=0;
 
    }
 
 
          redLED.setDutyCycle(count);
          Thread.sleep(1000);
 
    }
 
    }
 
 
    }

0.1
0.0
-0.1
Exception in thread "main" PhidgetException 0x15 (Invalid Argument)
Value must be in range: 0.000000 - 1.000000.
at com.phidget22.DigitalOutputBase.setDutyCycle(Nativ e Method)

Originally Posted by Norm

Where is the code that worked for 0 up to 1 to then down (but went too far)?
The fix was to use .9 vs 1 to stop going the incrementing.
You need to work with that code to have it stop when it gets to 0.

I suggested this:
while decrementing
if count not at boundary
then decrement count
else leave count where it is - stop changing its value <<< THIS MEANS DO NOTHING, leave the value of count unchanged.

      if (count!=0) {   //<<<<<< This will be true as soon as its value is changed from 0 
            incrementCount=false;

so the change I made in the code is I added the count!=0 in the conditional but I'm unsure if it works because of how the numbers count down I get this in the print

0.1
0.2
0.30000000000000004
0.4
0.5
0.6
0.7
0.7999999999999999
0.8999999999999999
0.9999999999999999
0.8999999999999999
0.7999999999999999
0.7
0.6
0.5
0.4
0.30000000000000004
0.20000000000000004
0.10000000000000003
2.7755575615628914E-17
-0.09999999999999998

So count never =0 so I assume the conditional coun!=0; is never not true and when count is zero instead of going to incrementCount it goes to else which is what I want but since in the print zero is never printed. I just want to know just the logic is it correct

 
 
package gettingstarted;
 
 
 
 
//Add Phidgets Library | You added a file called phidget22 when configuring your project. Import gives you access to the Phidgets library code inside that file. 
import com.phidget22.*;
 
 
public class LEDBrightness {
 
       //Handle Exceptions 
    public static void main(String[] args) throws Exception{
 
         double count=0;  // count starts at zero 
         boolean incrementCount =true;
 
        //Create 
        DigitalOutput redLED = new DigitalOutput();
 
        //Address 
        redLED.setHubPort(1);
        redLED.setIsHubPortDevice(true);
 
        //Open 
        redLED.open(1000);
 
        //Use your Phidgets with Duty Cycle 
 
 
    while (true) {
 
        if (incrementCount==true && count <=.99) { // if incrementCount is true which it starts as true count will incremetn by .1
            count+=.1;
        }else{
 
            count-=.1;  // if incrementCount is not true is will decrement the count by.1
 
        }
        if(incrementCount && count>=.99 && count!=0){ // when count is zero it does nothing
                                        // conditional where if incrementCount is true and the count has reached the boundary increment count will be false 
                                     //will go to the else and start decrementing 
            incrementCount=false;
        } else {
 
        }
 
        System.out.println(count);
 
 
 
 
 
 
          redLED.setDutyCycle(count);
          Thread.sleep(1000);
 
    }
 
    }
 
 
    }

Originally Posted by Norm

Yes, that is one of the problems with floating point numbers. Look at the printed values.
Instead of using == 0 use >= with a value very close to 0.
So when the value goes below 0.10000000000000003 then stop decrementing

The code has merged two parts of the logic into one.
begin loop
if incrementCount
then increment count
else decrement count
if count > .9
then incrementCount = false << stop incrementing when at 1
if not incrementCount <<< now decrementing count
then if count > .1 then decrement count << keep decrementing, stop when at lower boundary
end loop

 
package gettingstarted;
 
 
 
 
//Add Phidgets Library | You added a file called phidget22 when configuring your project. Import gives you access to the Phidgets library code inside that file. 
import com.phidget22.*;
 
 
public class LEDBrightness {
 
       //Handle Exceptions 
    public static void main(String[] args) throws Exception{
 
         double count=0;  // count starts at zero 
         boolean incrementCount =true;
 
        //Create 
        DigitalOutput redLED = new DigitalOutput();
 
        //Address 
        redLED.setHubPort(1);
        redLED.setIsHubPortDevice(true);
 
        //Open 
        redLED.open(1000);
 
        //Use your Phidgets with Duty Cycle 
 
 
    while (true) {
 
        if (incrementCount==true && count <=.99) { // if incrementCount is true which it starts as true count will incremetn by .1
            count+=.1;
        }else{
 
            count-=.1;  // if incrementCount is not true is will decrement the count by.1
 
        }
        if(incrementCount && count>=.99 && count>=.10000000000000003){ // when count is zero it does nothing
                                        // conditional where if incrementCount is true and the count has reached the boundary increment count will be false 
                                     //will go to the else and start decrementing 
            incrementCount=false;
        } else {
            count=0; 
        }
 
        System.out.println(count);
 
 
 
 
 
 
          redLED.setDutyCycle(count);
          Thread.sleep(1000);
 
    }
 
    }
 
 
    }

the change I made is instead of count!=0; I put in the decrement conditional that

 if(incrementCount && count>=.99 && count>=.10000000000000003)

so that if it is greater than .99 and greaterthan or equal to .100..3 that it will decrement, my else is if it isn't greater than .1000..3 that count=0; therefore staying at 0 and since incrementCount is false it cant go up but what I'm getting is that it prints
0.0
0.0
0.0
0.0

i assume that this is because its checking the statement for decrementing and after it increments its sets it self to zero but I'm unsure how i coul dmake it do nothing or stay at zero