You could add some friction to the line that changes the upwards y.

On a sidenote when posting code: Please post the code, select the code, then press the forum's "Insert Code" button. If you follow those steps, the code will be correctly posted (see below).

Adapted Code

1. float x =32, y =128;
2. float dx, dy;
3. float gravity = 5;
4. float ballsize =20;
5. float friction = 0.7;
6.  
7. void setup() {
8.   size(512, 512, P3D);
9.   fill(255);
10.   noStroke();
11.   frameRate(20);
12.   background(0);
13.  
14.   dx=5;
15.   dy=10;
16. }
17.  
18. void draw() {
19.   background(0);
20.   translate(x, y);
21.   ellipse(0, 0, ballsize, ballsize);
22.  
23.   if (x>width-ballsize/2 || x<ballsize/2) {
24.     dx = -dx;
25.   }
26.   if (y>height - ballsize/2) {
27.     dy = -dy * friction;
28.   } else {
29.     dy += gravity;
30.   }
31.   x += dx;
32.   y += dy;
33. }
    

It's never a good idea to use the frameRate to change the speed of the drawing/movement in your sketch.

For specific timing you could use millis(). For timing from a specific moment you can additionally have a timerStarted variable to store the starting time.

You could use the lerp function for accurate linear interpolation.

Combining the above two, you could make sure that the x position changes during a minute from 0 to width.

The great thing about Processing is that you can just try it yourself and see the direct result on your screen.

Feel free to experiment with the code to see what happens.

still working on the first / initial question (not the 2 minutes issue   )

1. float x =32, y =128;
2. float dx, dy;
3. float start_dy;
4. float gravity = .9;
5. boolean bouncingStopped=false;
6. final float ballsize = 20;
7. final float damping = 0.92; // for x when it rolls
8. void setup()
9. {
10.   size(512, 512, P2D);
11.   fill(255);
12.   noStroke();
13.   // frameRate(20);
14.   background(0);
15.   dx=2.5;
16.   dy=4.0; 
17.   start_dy=abs(dy);
18. }
19. void draw()
20. {
21.   background(0);
22.   // reflection
23.   if (x>width-ballsize/2 || x<ballsize/2)
24.     dx = -dx;
25.   if (y>height - ballsize/2)
26.     dy = -abs(dy);
27.   // Gravity changes y-movement
28.   dy += gravity;
29.   // draw
30.   ellipse(x, y, ballsize, ballsize);
31.   // Movement
32.   x += dx;
33.   y += dy;
34.   // Does the bouncing end?
35.   if (abs(dy) < start_dy-gravity &&
36.     y > height-(ballsize/2) ) {
37.     // yes, stop
38.     println("stop");
39.     dy=0;
40.     y=height-ballsize/2;
41.     gravity=0;
42.     bouncingStopped=true;
43.   }
44.   // if bouncing ended, roll on a bit...
45.   if (bouncingStopped) {
46.     if (abs(dx) > .09) {
47.       dx*=damping;
48.     }
49.     else
50.     {
51.       if (dx!=0)
52.         println("full stop");
53.       dx=0;
54.     }
55.   }
56.   //
57. }

@ elisa.pro

you wrote

How can I make the ball ( Two minutes) to travel from left edge of screen to the right? And back to the left edge of the screen again

What do you mean by this: It starts at x=0 goes all the way to the right and back again till x=0 again.
And stop exactly at x=0 and then 2 minutes are over.
And this go rigth and go left again happens only once?

Do you mean this?

So it must move very very very slowly indeed

here [edited]

please read and understand
millis, abs, lerp, map....

1. //
2. float x =0, y =128;
3. // float dx;
4. float dy;
5. float gravity = .345; // .34
6. float ballsize =20;
7. int startingTime;
8. boolean goingToTheRight = true;
9. boolean stillRunning=true;
10. //
11. void setup()
12. {
13.   size(512, 512, P2D);
14.   fill(255);
15.   noStroke();
16.   frameRate(20);
17.   background(0);
18.   // dx=5;
19.   dy=6;
20.   startingTime=millis();
21. }
22. void draw()
23. {
24.   background(0);
25.   // translate(x, y);
26.   ellipse(x, y, ballsize, ballsize);
27.   /*  if (x>width-ballsize/2 || x<ballsize/2)
28.    dx = -dx;*/
29.   if (y>height - ballsize/2)
30.     dy = -abs(dy);
31.   dy += gravity;
32.   //x += dx;
33.   if ( goingToTheRight ) {
34.     // go right
35.     // calculate x (60'000 being 1 Minute)
36.     x = lerp(ballsize/2, width-ballsize/2, map (millis()-startingTime, 0, 60000, 0, 1));
37.     // if reached right wall
38.     if (x>=width-ballsize/2 || millis()-startingTime > 60000) {
39.       // turn
40.       goingToTheRight=false;
41.     } // if
42.   } // if
43.   else {
44.     // go left
45.     if (stillRunning) {
46.       // calculate x (60'000 being 1 Minute, 120'000 being 2 Minutes)
47.       x = lerp(width-ballsize/2, ballsize/2+3, map (millis()-startingTime, 60000, 120000, 0, 1));
48.       // if reached left wall
49.       if ( x <= ballsize/2+3 && y > width -10) {
50.         // stop
51.         x=ballsize/2;
52.         y=height-ballsize/2;
53.         // dx=0;
54.         dy=0;
55.         gravity=0;
56.         stillRunning=false;
57.       }
58.     }
59.   } // else
60.     y += dy;
61. } 
62. //

I feel lerp is not necessary, map alone could be enough ....

Yeah, I think you don't need lerp, map is enough

Elisa, if you want to learn how to program, spend the time to understand and master the material. Having other people do your homework for you hurts your learning. It doesn't actually benefit you to pass a class or test that you didn't understand. Your teachers will only know that they need to help you if you show signs of not understanding. Good luck.

I think line 36   x = lerp(ballsize/2, width-ballsize/2, map (millis()-startingTime, 0, 60000, 0, 1));   x = map (millis()-startingTime, 0, 60000,  ballsize/2, width-ballsize/2 );