First of all, don't specify a framerate. That's a deprecated function; your sketch will run as fast as it can.

Next, use this logic to do things at a certain time apart:

I haven't seen that either.
I still use it sometime (slow frame rates) eg. when I want some effects or reduce the number of println, etc.

framerate - (small r) was deprecated iin the change to version 1.0 of Processing (see this)
frameRate - (big R) is not deprecated and in fact was the replacement for framerate
----------------------------------------------------------------------------------------------------------------------------------------

With regard to the timer the code shown below executes a method called getData() every 1000 milliseconds and sendData() every 500 milliseconds and is not affected by/ dependant on the frame rate.

The core to this sketch is the GTimer class (copied from the G4P library) which is a wrapper class for the Java Sing class Timer). I have left all the class comments so the code should be fairly easy to follow.

The output from the sketch is
SEND DATA 30          @ 502
GET DATA  60          @ 1000
SEND DATA 60          @ 1001
SEND DATA 90          @ 1501
GET DATA  120         @ 2000
SEND DATA 120         @ 2001
SEND DATA 150         @ 2501
GET DATA  180         @ 3000
SEND DATA 180         @ 3001
SEND DATA 210         @ 3501
GET DATA  240         @ 4000
SEND DATA 240         @ 4001
SEND DATA 270         @ 4501
GET DATA  300         @ 5000
SEND DATA 300         @ 5001
SEND DATA 330         @ 5501

The first number is the frame number and the second the time since the sketch started in milliseconds. You can see send data is executed every 500ms and get data every 1000ms.

1. import java.awt.event.ActionEvent;
2. import java.awt.event.ActionListener;
3. import java.lang.reflect.Method;
4. import javax.swing.Timer;
5. GTimer getTimer, sendTimer;
6. long ctime;
7. int count = 0;
8. 
   
9. void setup() {
10.   size(300, 300);
11.   getTimer = new GTimer(this, this, "getData", 1000);
12.   sendTimer = new GTimer(this, this, "sendData", 500);
13.   ctime = millis(); // used to prove timer intervals
14.   frameRate(100); // Try different values will not affect timers!
15.   // other initialisation code
16.   getTimer.start();
17.   sendTimer.start();
18. }
19. 
    
20. void getData() {
21.   long ct = millis() - ctime;
22.   println("GET DATA  " + count + "\t\t @ " + ct);
23. }
24. 
    
25. void sendData() {
26.   long ct = millis() - ctime;
27.   println("SEND DATA " + count + "\t\t @ " + ct);
28. }
29. 
    
30. void draw() {
31.   count++;
32. }
33. 
    
34. public class GTimer {
35.   /** This must be set by the constructor */
36.   protected PApplet app;
37.   /** The object to handle the event */
38.   protected Object eventHandlerObject = null;
39.   /** The method in eventHandlerObject to execute */
40.   protected Method eventHandler = null;
41.   // The number of repeats i.e. events to be fired.
42.   protected int nrepeats = -1;
43.   protected Timer timer = null;
44. 
    
45.   /**
46.    * Create the GTimer object with this ctor.
47.    *
48.    * 'methodName' is the method/function to be called every 'interval'
49.    * milliseconds. 'obj' is the object that contains the method/function
50.    * 'methodName'
51.    *
52.    * For most users 'methodName' will be in their main sketch so this
53.    * parameter has the same value as 'theApplet'
54.    *
55.    * @param theApplet a reference to the PApplet object (invariably <b>this</b>)
56.    * @param obj the object that has the method to be executed (likely to be <b>this</b>)
57.    * @param methodName the name of the method to be called by the timer
58.    * @param delay the initial delay and the time (in millisecs) between function calls
59.    */
60.   public GTimer(PApplet theApplet, Object obj, String methodName, int delay) {
61.     app = theApplet;
62.     createEventHandler(obj, methodName);
63.     // If we have something to handle the event then create the Timer
64.     if (eventHandlerObject != null) {
65.       timer = new Timer(delay, new ActionListener() {
66.         public void actionPerformed(ActionEvent e) {
67.           fireEvent();
68.         }
69.       });   
70.       timer.setInitialDelay(delay);
71.       timer.setDelay(delay);
72.       timer.stop();
73.     }
74.   }
75. 
    
76.   /**
77.    * See if 'obj' has a parameterless method called 'methodName' and
78.    * if so keep a reference to it.
79.    *
80.    * @param obj
81.    * @param methodName
82.    */
83.   protected void createEventHandler(Object obj, String methodName) {
84.     try {
85.       this.eventHandler = obj.getClass().getMethod(methodName, new Class[0] );
86.       eventHandlerObject = obj;
87.     }
88.     catch (Exception e) {
89.       eventHandlerObject = null;
90.       System.out.println("The class " + obj.getClass().getSimpleName() + " does not have a method called " + methodName);
91.     }
92.   }
93. 
    
94.   /**
95.         * Attempt to fire an event for this timer. This will call the
96.         * method/function defined in the ctor.
97.         */
98.   protected void fireEvent() {
99.     if (eventHandler != null) {
100.       try {
101.         eventHandler.invoke(eventHandlerObject, (Object[]) null);
102.         if (--nrepeats == 0)
103.           stop();
104.       }
105.       catch (Exception e) {
106.         System.out.println("Disabling " + eventHandler.getName() + " due to an unknown error");
107.         eventHandler = null;
108.         eventHandlerObject = null;
109.       }
110.     }
111.   }
112. 
     
113.   /**
114.    * Start the timer (call the method forever)
115.    */
116.   public void start() {
117.     this.nrepeats = -1;
118.     if (timer != null)
119.       timer.start();
120.   }
121. 
     
122.   /**
123.    * Start the timer and call the method for the number of
124.    * times indicated by nrepeats
125.    * If nrepeats is <=0 then repeat forever
126.    *
127.    * @param nrepeats
128.    */
129.   public void start(int nrepeats) {
130.     this.nrepeats = nrepeats;
131.     if (timer != null)
132.       timer.start();
133.   }
134. 
     
135.   /**
136.    * Stop the timer (can be restarted with start() method)
137.    */
138.   public void stop() {
139.     if (timer != null)
140.       timer.stop();
141.   }
142.   /**
143.    * Is the timer running?
144.    * @return true if running
145.    */
146.   public boolean isRunning() {
147.     if (timer != null)
148.       return timer.isRunning();
149.     else
150.       return false;
151.   }
152. 
     
153.   /**
154.    * Set the interval between events
155.    * @param interval delay between events in milliseconds
156.    */
157.   public void setInterval(int interval) {
158.     if (timer != null)
159.       timer.setDelay(interval);
160.   }
161. 
     
162.   /**
163.    * Set the delay before the first event is triggered
164.    * @param initDelay initial delay in milliseconds
165.    */
166.   public void setInitialDelay(int initDelay) {
167.     if (timer != null)
168.       timer.setInitialDelay(initDelay);
169.   }
170. 
     
171.   /**
172.    * Sets the initial delay and the interval between events. <br>
173.    * This is equivalent to calling both - <br>
174.    * <pre>
175.    * setInterval(delay);
176.    * setInitialDelay(delay);
177.    * </pre><br>
178.    * @param delay initial delay and interval in milliseconds
179.    */
180.   public void setDelay(int delay) {
181.     if (timer != null) {
182.       timer.setInitialDelay(delay);
183.       timer.setDelay(delay);
184.     }
185.   }
186. 
     
187.   /**
188.    * Get the interval time (milliseconds) between
189.    * events.
190.    * @return interval in millsecs or -1 if the timer failed to
191.    * be created.
192.    */
193.   public int getInterval() {
194.     if (timer != null)
195.       return timer.getDelay();
196.     else
197.       return -1;
198.   }
199. 
     
200.   /**
201.    * Get the initial delay time (milliseconds).
202.    * @return initial delay in millsecs or -1 if the timer failed to
203.    * be created.
204.    */
205.   public int getInitialDelay() {
206.     if (timer != null)
207.       return timer.getInitialDelay();
208.     else
209.       return -1;
210.   }
211. 
     
212.   /**
213.    * See if the GTimer object has been created successfully
214.    * @return true if successful
215.    */
216.   public boolean isValid() {
217.     return (eventHandlerObject != null && timer != null);
218.   }
219. }

Thanks everybody for the replies. Great!
I meant frameRate(120), sorry for the confusion. You do get an error when you use framerate().
@ quarks
That looks very good. A question:
What is the benefit of using the library instead of using the Java Timer class straight away?

Thanks very much, danielle

What is the benefit of using the library instead of using the Java Timer class straight away?

No real benefit if you are used to programming using Java classes and are comfortable creating an event handler for the Swing Timer class. Novices would probably find the GTimer class easier to use since the code to create, initialise and start the timers is very simple (it is all in setup() method)

That's the point of lot of Processing libraries (and even of Processing itself): to wrap and hide some complexities from Java to offer a simple and easy to use interface.

Hi quarks,
Yes, it looks pretty simple. I'm giving it a go. Just a question (may be a bit silly) but where do I put the GTimer class file? I've put it in the same folder as the sketch and I get an error that says Problem moving GTimer.java to the build folder.
In your example you put it under the code but as the sketch is pretty complicated as it is I'd like to put it in a separate file.
Some time later...
I've now put the guicomponents library in the Processing library folder and imported guicomponents.GTimer. Now I can use the class. Is this the way to go or is there another/better way?

Thanks for you help, best, danielle.

Hmm, I've bumped into something.
The reason I put frameRate(10) for now is because my serial port is firing every 100 milliseconds. It is the data from the port that I gather into different arrays which I later combine into JSON objects which get send to the server. This is the code I have now:

1. if(send_w_data.length < sendAmount){
          send_w_data = append(send_w_data, wind);
          send_t_data = append(send_t_data, temp);
          // make unix timestamp
          long now = System.currentTimeMillis();
          send_timestamp.add(now);
        }
        if(send_w_data.length == sendAmount){
          sendData();
2. }
   

So I only want to send the data when the arrays hold 5 items. After the array/JSON is send I clear the arrays for the next five data points. How will I know that the filling of the arrays will coincide with the timer?

Thanks for you thoughts on this, best, d

Another conceptually important thing to consider is the difference between UI and data handling. You never want to do something on the UI thread that can potentially halt, or stop working. That would lead to an unresponsive UI.

If you're doing something that doesn't concern the UI (for example, contacting a server to exchange data) then you shouldn't do it inside draw ( see tfguy44's example). The GTimer class hides the complexities of background threads as well, which makes it far superior for your purposes Danielle.

However, tfguy44's example works well for quick tests, and I use it often in those cases. (even when I shouldn't)

Thanks for your thoughts a__g.
Do I understand correctly that you imply that I should do the array counting if(send_w_data.length < sendAmount){
inside the function called by the timer to send data, eg getData()?
I was also considering using the serial event but then the software would be depending on the hardware. Maybe that's bad practice too?

Thanks in advance for your advice, best, d

With regard to where to place the GTimer class you have four options

1. Use the code that I gave in the main sketch window.
2. Move the GTimer class code from above and put it in its own tab e.g. GTimer.pde
3. Copy the GTimer.java file from the G4P library into the existing sketch folder
4. Import the guicomponents library
   

Option 1 is out because you want (rightly) to keep the main sketch code short and tidy
Option 2 is fine and will work exactly the same way as option 1.
Option 3 will work if you don't change the filename and you remove the statement package guicomponents;
Option 4 makes the GTimer class avaialble along with the rest of the library.

The problem with option 4 is that you get the entire library included in your distribution but since it is only 87.1kB thats not a real problem. If you only need the GTimer class then option 3 is probably best in this case. (Note simply copying java source files from a library will not work in all cases).

The methods getData and sendData are executed by the timer at the appropriate time intervals whatever the frame rate (within reason) so you should not use frameRate in an attempt to match these processes.

a__g said

You never want to do something on the UI thread that can potentially halt, or stop working. That would lead to an unresponsive UI.

This is absolutely correct but the statement

The GTimer class hides the complexities of background threads as well, which makes it far superior for your purposes

is misleading because it would suggest that getData and sendData are run on a thread seperate from the UI thread and this is not true. It is only timer that runs on a different thread not the methods it triggers.

What actually happens is that at the appropriate time interval GTimer creates an event that is placed on the UI thread event queue. When the UI thread becomes active it then processes each event in the queue in turn, so if one event takes a long time to process then the UI can become unresponsive.

To avoid this then in your program should avoid waiting for the server if it is not ready so create a couple of boolean variable e.g.
boolean serverReadyToReceive, serverIsReadyToSend;

getData()
      if(serverIsReadyToSend)
            set  serverIsReadyToSend to false
            getData
      endif

sendData()
      if(serverReadyToReceive)
            set  serverReadyToReceive to false
            sendData
      endif
           
The boolean variables would be set back to true by some other part of your program. You want to avoid something like

. getData()
     while(serverIsReadyToSend is false)
                  wait
       end while
     getData

As this would freeze UI event handling, including mouse and keyboard until the server became ready.

HTH