I am no experience in controlling several applets from a common applet, but I am not sure if that's a good idea. Particularly, the idea of having the draw() of the main applet controlling those in the secondary applets is disturbing...
Perhaps the main class should not be a PApplet and should let the secondary applets draw at their own rhythm.

These secondary applets have no knowledge of the main class. So they cannot reference something from there*.
You can either pass the main class (this) or a reference to the Circle to the constructor (for example) of each sub-applet.

* Well, not exactly, true in the general case, but since the Circle object is static and public, you can reference it directly like:
Circle aGreenCircle = EllipseProblem.aNewCircle;

But passing the reference to the object is probably the cleanest version, particularly for more complex programs.

I agree with everything that PhiLho has said and I am also concerned about the classes you have created.

For instance the two classes called Applet1 and Applet2 are the same effectivley the same the only difference being that value stored in a attribute. Same problem with the classes Frame1 and Frame2. This is poor OO design which will cause loads of problems - just think of the number of classes needed if you wanted 8 linked Windows.

Having said all that there is a solution to your problem.

The code below works I have tested it, but it uses classes from the G4P library. Download the G4P library from here, extract the library from the zip file and locate the file called guicomponents.jar

Since you are using Proclipsing there will be a folder called lib inside the Eclipse Project, copy guicomponents.jar into this folder, if Eclipse is open then you need to refresh the project.

Now you have to modify the project's build path, right click on the project name and select Build Path | Configure Build Path then in the dialog box select the Libraries tab. Click on Add External JARs then browse to the guicomponents.jar file and click OK

Now your project can make use of anything in the G4P library including its support of multiple Windows.

You have not posted your Circle class so I had to create my own which I called CircleQ so it would not conflict with your class. Add this class to the project.

1.     public class CircleQ {
2.         public int x,y,r,col;
3. 
   
4.         public CircleQ(int x, int y, int r, int col) {
5.             this.x = x;
6.             this.y = y;
7.             this.r = r;
8.             this.col = col;
9.         }
10.     }

The next class is the core of the solution and holds all the dtata to be shared between the Windows. The key here is that shared attributes should be public static

1.     public class SharedData {
2.         public static CircleQ cq;
3.     }

The final class is the main PApplet and when you run it it will display 4 Windows (with different background colours). Click on the one with the gray background to make it active. The wasd keys will move the circle and the zx keys decrease/increase the circles radius. Note that the changes are shown in all 4 Windows.

HTH

1.     import guicomponents.GWinApplet;
2.     import guicomponents.GWinData;
3.     import guicomponents.GWindow;
4.     import processing.core.PApplet;
5. 
   
6.     public class LinkedWindows extends PApplet {
7.         private GWindow[] window;
8. 
   
9.         public void setup(){
10.             size(200,200);
11.             SharedData.cq = new CircleQ(100,100,60,color(128,0,128));
12.             createWindows();
13.         }
14. 
    
15.         public void createWindows(){
16.             int col;
17.             window = new GWindow[3];
18.             for(int i = 0; i < 3; i++){
19.                 col = (200 << (i * 8)) | 0xff000000;
20.                 window[i] = new GWindow(this, "Window "+i, 130+i*210, 100+i*100, 200, 200, false, JAVA2D);
21.                 window[i].setBackground(col);
22.                 window[i].addDrawHandler(this, "windowDraw"+i);
23.             }
24.         }
25. 
    
26.         /**
27.          * Draw for the main window
28.          */
29.         public void draw(){
30.             pushMatrix();
31.             background(192);
32.             fill(0);
33.             text("Window 0", 20,20);
34.             if(SharedData.cq != null){
35.                 fill(SharedData.cq.col);
36.                 ellipseMode(CENTER);
37.                 translate(SharedData.cq.x, SharedData.cq.y);
38.                 ellipse(0, 0, SharedData.cq.r, SharedData.cq.r);
39.             }
40.             popMatrix();
41.         }
42. 
    
43.         public void keyTyped(){
44.             switch(key){
45.             case 'w':
46.                 SharedData.cq.y -= 4;
47.                 break;
48.             case 's':
49.                 SharedData.cq.y += 4;
50.                 break;
51.             case 'a':
52.                 SharedData.cq.x -= 4;
53.                 break;
54.             case 'd':
55.                 SharedData.cq.x += 4;
56.                 break;
57.             case 'z':
58.                 SharedData.cq.r = max(SharedData.cq.r - 4, 40);
59.                 break;
60.             case 'x':
61.                 SharedData.cq.r = min(SharedData.cq.r + 4, 80);
62.                 break;
63.             }
64.         }
65. 
    
66.         public void windowDraw0(GWinApplet appc, GWinData data){
67.             appc.pushMatrix();
68.             appc.fill(255);
69.             appc.text("Window 0", 20,20);
70.             if(SharedData.cq != null){
71.                 appc.fill(SharedData.cq.col);
72.                 appc.ellipseMode(CENTER);
73.                 appc.translate(SharedData.cq.x, SharedData.cq.y);
74.                 appc.ellipse(0, 0, SharedData.cq.r, SharedData.cq.r);
75.             }
76.             appc.popMatrix();
77.         }  
78. 
    
79.         public void windowDraw1(GWinApplet appc, GWinData data){
80.             appc.pushMatrix();
81.             appc.fill(0);
82.             appc.text("Window 1", 20,20);
83.             if(SharedData.cq != null){
84.                 appc.fill(SharedData.cq.col);
85.                 appc.ellipseMode(CENTER);
86.                 appc.translate(SharedData.cq.x, SharedData.cq.y);
87.                 appc.ellipse(0, 0, SharedData.cq.r, SharedData.cq.r);
88.             }
89.             appc.popMatrix();
90.         }
91.     
92.         public void windowDraw2(GWinApplet appc, GWinData data){
93.             appc.pushMatrix();
94.             appc.fill(255,255,0);
95.             appc.text("Window 2", 20,20);
96.             if(SharedData.cq != null){
97.                 appc.fill(SharedData.cq.col);
98.                 appc.ellipseMode(CENTER);
99.                 appc.translate(SharedData.cq.x, SharedData.cq.y);
100.                 appc.ellipse(0, 0, SharedData.cq.r, SharedData.cq.r);
101.             }
102.             appc.popMatrix();
103.         }  
104.     }

Thanks so much quarks for your help. Your code worked perfectly. A static class is needed for two applets to communicate with each other. 

"A static class is needed for two applets to communicate with each other."
No.
As I wrote, you can pass references of an object to another object / class. So it also applies to applets.

The logic behind my class structure in this sample code is that my real code uses two complete and different applets. One of them is using the 2d engine, and the other is using opengl

In G4P the GWindow objects created can use any renderer (P2D, JAVA2D, P3D, OPENGL), they do not all need to be the same.

In the Shapes3D library some of the examples use G4P to create multiple windows with different renderers, OPENGL for 3D display and JAVA2D for the control windows. In this example sketch click on the button in the 3D display to open the 2D control window.

P.S. I used the static class as a convenience, there are other ways to do this as PhiLho pointed out.