Skyscraper Window Cleaner Robot

In this project, a window cleaning robot was designed. It features rotating cleaning rollers to clean the window (or whiteboard in the test case) and moves around the building using a system of two cables. Varying the lengths of these cables allows for the movement of the robot.

Step 2. Project Motivation

Step 3. Project Working Modes / Functionality

Step 4. High-Level Design

Step 5. Design of Subsystems

a. Mechanical Systems

1. Requirements
2. Design process & Considerations of material and manufacturing choices
3. CAD Design
4. Testing & Final design

b. Circuitry & Sensors

1. Requirements
2. Design process & Considerations of components
3. Final Circuit Diagram
4. Testing & Final design
5. Exact components used

c. Software

1. Requirements
2. Design process & Considerations of functions
3. Code Flow Diagram
4. Provided code

Step 6. Integration Guide

Step 7. Demo Project Show + Quick Start Guide

Step 8. Critical Review of the Project

Step 9. Sustainability

Step 10. Bill of Materials

Step 11. Our Team

Step 12. Project Repo

Window cleaning of skyscrapers is a dangerous profession for the people that perform it every day. It is also a very hard profession since the cleaners are always subjected to the elements including rain, wind, hail, ... For the owners of the building, it is always a very expensive endeavor to clean the windows of their building since the labor costs are quite high (~20 euros/hour). A robot with the capacity to take over this job could greatly reduce costs and risks.

To further prove the point of skyscraper window cleaning being unsafe, it was voted the most dangerous job in 2013 in the UK [1]. Furthermore, in 2014, two window cleaners got stuck on the 68th floor of the World Trade Center, where they had to wait hours before being rescued [2].

The prototype that was built has two main functionalities:

• It can move up and down using its cable system.
• It can clean a window (or whiteboard) using its rotating cleaning rollers.

The robot should be operated in a relatively safe environment. It has no implemented stabilization system (aside from the cable guidance), meaning that it can't be used for high-altitude cleaning.

To achieve the desired performance for the robot, two prototypes were built. An initial prototype was designed based on theoretical considerations (datasheets information, calculations, CAD model). However, during the first tests made on this first prototype, an important problem was encountered: the torque provided by the two stepper motors was not sufficient to lift up the robot... Then, various additions and changes were made to solve this problem leading to a second and final prototype that successfully lifts up itself.

The initial prototype consisted of two subsystems. The first subsystem is the moving part and it contains two drums, each connected to a stepper motor by a set of two gears. Cables attached around the drums also pass through cable guides to make sure they always leave the robot in the same place and to improve its performance.

The second subsystem is the cleaning part composed of two cleaning rollers. Each roller is connected to a servo motor that has been modified to turn 360 degrees. The use of servo motors allows high torque and easy placement in the robot.

In this section, the initial and final designs of the two subsystems - moving and cleaning subsystems - are discussed, including the mechanical designs, the electronic circuits and the Arduino code that are used to actuate each subsystem.

a. Mechanical systems

In this first subsection, the mechanical designs are discussed. Most of the parts of the robot were laser-cut and 3D-printed from self-made models.

1- Requirements

Regarding the movement part, a minimal amount of torque will be needed at the place where the drum is located. This torque depends on the mass the robot will have and on the radius of the drum that will be used to roll up the cable. The minimal torque needed will also depend on the angle under which the robot hangs on the building.

Concerning the cleaning part, the determination of the minimal torque is more difficult. The torque will depend on the frictional force between the rollers and the window. This force depends on the frictional constant (static at first then dynamic when the roller gets moving) and the normal force with which the robot pushes against the window. This force will depend on the mass of the robot and the angle between the robot and the building, which will be largest near the top of the building. The results of these calculations can be found in the following section.

2- Design process & Considerations of material and manufacturing choices

In order to make sure the stepper will provide enough torque for the movement part of the robot, a gear reduction is added. To calculate the minimal needed torque, a mass of 2.5 kg is assumed for the robot as well as a drum radius of 3 cm and an angle of 30° between the robot and the building. This provides a torque of 0.21 Nm. The classical stepper motor NEMA-17 should be able to provide this. However, the system will also have quite a lot of internal friction. To somewhat increase the margin, a gear ratio of 1.1 is added. The axles on which the gears and drums turn will be made of steel bars. The gears will be fabricated out of plexiglass to make sure that the teeth of the gears don’t break under considerable stress. The gears can be easily laser-cut out of a sheet of plexiglass. The drums are quite thick, and this allows them to be 3D-printed out of PLA since this material should be able to withstand the stresses when the part is this thick. To further limit the friction, ball bearings are also introduced in the drum design.

For the cleaning part, a torque value of 0.042 Nm is calculated. This is however a rough estimate since the actual friction coefficient is difficult to determine. To provide ample torque, servo motors will be used that have been modified to make full revolutions. These servo motors will be directly connected to an axis on which the cleaning rollers have been attached. The axis will again consist of a steel part and the connections between the servo motor and the axis will be 3D-printed. Ball bearings are again used to reduce the friction of the axis with the 3D-printed components.

To produce the cleaning rollers, paintbrushes are used. A towel is then turned and glued around this roller twice to make it thicker. This way only the towel will touch the window when the robot is moving upwards and no damage to the window will be done.

Finally, cable guides will be introduced in the design. These guides will make sure the cable always leaves the robot in the same place and will stabilize the design.

3- CAD design

Images of the initial CAD design can be seen in the images above. The side plates are not added so the insides are clearly visible.

4- Testing & Final design

The two subsystems are individually tested to make sure that they work properly before they are assembled together. For the cleaning part, there are no problems to report. However, concerning the moving part, an important problem has emerged from these first tests: the stepper motors were slipping and the robot was unable to lift itself from the ground. To help solve this problem, the torque provided by the stepper motors has been increased by replacing the drum-gear system with a single smaller drum. By connecting the drum directly to the stepper motor, the torque is delivered more optimally to the robot (frictional losses in the drums and in the gears teeth are avoided). In addition, the weight of the robot has also been reduced as much as possible. The videos of these tests can be seen above. A video is provided showing all the tests performed to solve the problem of lifting up the robot. Another video is also provided where the cleaning rollers turn and clean a whiteboard.

b. Circuitry & Sensors

In this subsection, the design of the electronic circuit is discussed. The design includes two stepper motors and two modified servo motors controlled by an Arduino board using a prefabricated CNC shield.

1- Requirements

Since a stepper motor can be moved in steps this system is chosen to know how far the robot has wound up its cable. Concerning the cleaning part, no sensors are required since the cleaning rollers only need to turn and it is not important to know how fast they are turning. For the four actuators together, there will also be a current requirement. This requirement can however be met by a simple lab source.

2- Design process & Considerations of components

For the moving part, each stepper motor can be controlled using a driver. This allows fewer ports to be used on the Arduino board and provides an easier control than trying to control the stepper directly with the Arduino (using the Stepper library). Since we use two stepper motors and therefore two drivers, it is easier to use a CNC shield than to remake the circuit on a breadboard. Note that the CNC shield is standard and can be used with two standard types of stepper drivers namely the A4988 and DRV8825.

Regarding the cleaning part, the servo motors are controlled using a prefabricated H-bridge. The full functionality of the H-bridge will not be used since the motors only need to turn in one direction. Important to note is that servo motors were chosen because of their high torque, but since they do not turn full revolutions out of the box, some changes are made to make them turn 360°. In order to do this, the internal encoders are cut from the servo motors and a small pin that physically keeps the motor from turning too far is removed. Pictures of this pin are also provided above.

In order to provide power to the stepper motors, a minimum voltage of 12V is required. However, the servo motors can only operate properly between 5V and 7V. To limit the number of power supplies needed, a voltage reduction is performed using the voltage drop over diodes. This way, the resulting voltage will be independent of the load, unlike with a resistive voltage reduction. The amount of current the servo motors will draw is quite small (max. 500 mA) and this means no heavy-duty components will be required. This also means a breadboard can be used to fabricate this circuit since the current should not pose a danger to the board.

3- Final Circuit Diagram

The final circuit is given in the diagram above. An image of the practical implementation of this diagram is also provided.

4- Testing & Final design

As already said, the tests for the cleaning part were successful. However, concerning the moving part, the stepper motors were not able to lift the robot. To solve this problem, changes in the electronics were also made:

• To minimize power losses in the wires, direct connections have been made by using the CNC shield instead of the initial breadboard circuit. Some electrical wires have also been shortened.
• The potentiometer on the stepper drivers has been adjusted to increase the maximum current that the stepper motors can receive (up to ~1A for each stepper motor).
• The way the stepper motors are operated was changed. Instead of full steps with a big delay (30 ms), 1/16 of a step at a time is used with a smaller delay (3 ms). This increases the torque that the stepper motors can provide.

At the end of the day, these changes combined with the mechanical adjustments led to the robot being able to successfully lift itself up.

An important side note is that according to the theoretical calculations the steppers should be able to lift the robot with the initial design. Keeping the original design and only changing the electronics might also provide a working prototype. Unfortunately, this could never be tested.

5- Exact components used

The following electronic components are used in the final circuit:

• 1x Arduino UNO
• 1x CNC shield
• 2x stepper drivers DRV8825 (A4988 drivers can also be used)
• 2x stepper motors NEMA-17
• 1x H-bridge L298N
• 2x servo motors MG996R
• 5x diodes
• 1x 1.6 ohm resistor
• a small breadboard
• some small jumper wires

c. Software

The Arduino code that allows to control stepper and servo motors is explained in this subsection.

1- Requirements

The code has to control the H-bridge to make the servo motors turn in one and the same direction. This direction is chosen so that the rotation of the rollers helps the robot to lift up. It has also to control the steppers and through this the movement of the robot. For the tests performed, both steppers have to rotate equally to keep the robot straight. However, for the final operation, the two steppers have to turn a different number of steps so that the robot can move vertically and horizontally, covering the entire building.

2- Design process & Consideration of functions

To control a stepper through the driver, the direction pin has to be set to high or low depending on the desired direction of rotation and for each pulse sent to the step pin, the stepper rotates one step, which corresponds to a 3.6° angle for the NEMA-17. A pulse can be generated by setting the step pin to high for a certain time and then to low for another time. An important aspect of the programming was to make the steppers turn smoothly. In order to do this, the steppers will not turn full-step, but 1/16 of a step at a time and this with a small delay of 3 ms. This allows higher torque and a smoother motion.

The control of the H-bridge for the servo motors is very simple. All pins need to be put to high and they need to remain high for the duration of the operation of the robot. The pins need to be set to high in the loop, however. When this is done in the setup of the code, the pins will go low again when the loop starts.

To control the complete movement of the robot, it is interesting to implement some functions in the code. The 'moveUp' function allows the robot to move vertically. The direction of movement is defined by the sign of its argument: up if positive, down if negative. The desired vertical displacement (given as argument dy) is converted into a variation of the cable lengths and then into the number of steps each stepper have to rotate. Note that in this function, each stepper turns at the same speed. If one stepper needs to take more steps than the other, it will continue turning while the other is holding. Therefore, this function only works well for small displacements (here, dy=1cm). The 'moveRight' function is implemented in a similar way to the first one and allows horizontal movement: for a positive given argument dx, the robot moves to the right; to the left if the argument is negative.

3- Code Flow Diagram

The flow charts can be found in the images above. For the tests performed, the operation of the robot is quite simple: the robot is simply lifted up and the rollers rotate continuously. A flow chart is also provided for the complete movement of the robot. However, since it is more difficult and less accurate to turn the steppers at different speeds, another strategy was chosen: both steppers will turn at the same speed but the one that needs to make more steps continues to turn after the other one has finished and is holding.

4- Provided code

The code that was used to make the robot go up and turn the servos is given first. Some code is also provided that would be used to make the robot move across the entire board, meaning vertically and horizontally.

Code used for the tests:

// DEFINE THE PINS

#define Enable 8

#define dirPinX 5
#define stepPinX 2

#define dirPinY 6
#define stepPinY 3


void setup() {
  
  pinMode(Enable, OUTPUT);
  
  pinMode(dirPinX, OUTPUT);
  pinMode(stepPinX, OUTPUT);
  
  pinMode(dirPinY, OUTPUT);
  pinMode(stepPinY, OUTPUT);
  
  pinMode(4,OUTPUT);
  pinMode(7,OUTPUT);
  pinMode(11,OUTPUT);
  
  digitalWrite(Enable, LOW); // to enable the CNC shield
  
  // Choose the direction of rotation in order to roll the cables around the drums and move up
  digitalWrite(dirPinX, HIGH);
  digitalWrite(dirPinY, HIGH);
  
}

void loop() {
  
  // Make the servos continuously turn
  analogWrite(7,255);
  digitalWrite(4, LOW);
  digitalWrite(11, LOW);
  
  // Create pulses, each pulse makes the steppers turn one sixteenth of a step
  
  digitalWrite(stepPinX, HIGH);
  digitalWrite(stepPinY, HIGH);
  delay(3); // ms
  
  digitalWrite(stepPinX, LOW);
  digitalWrite(stepPinY, LOW);
  delay(3); // ms
  
}

Complete code for the movement on the whole building (untested):

// DEFINE THE PINS

#define Enable 8

// 1 = left stepper, 2 = right stepper

#define dirPin1 5
#define stepPin1 2

#define dirPin2 6
#define stepPin2 3


// DEFINE THE CONSTANTS

const float W = 1620; // building width, in mm
const float w = 210;  // distance between the two cable guides, in mm
const float r = 9;    // radius of the drum, in mm


// DEFINE THE VARIABLES

// (Initial) angles, in rad
float theta1 = 30 * (2*PI)/360;
float theta2 = 25 * (2*PI)/360;

// Cable lengths, from the robot to the top of the building, in mm
float L1;
float L2;

// (Initial) position on the building, in mm
int x = 0;
int y = 0; // starting from the ground

// Displacements allowed
int dx = 10;
int dy = 10;


void setup() {
  
  pinMode(Enable, OUTPUT);
  
  pinMode(dirPin1, OUTPUT);
  pinMode(stepPin1, OUTPUT);
  
  pinMode(dirPin2, OUTPUT);
  pinMode(stepPin2, OUTPUT);
  
  pinMode(4,OUTPUT);
  pinMode(7,OUTPUT);
  pinMode(11,OUTPUT);
  
  digitalWrite(Enable, LOW); // to enable the CNC shield
  
}


void loop() {
  
  // Make the servos continuously turn
  analogWrite(7,255);
  digitalWrite(4, LOW);
  digitalWrite(11, LOW);
  
  // Move on the building

  if ( x % (2*200) == 0 && x <= 1400 && y < 1800 ) {
    moveUp(dy);
    y = y + dy;
  }
  else if ( x % (2*200) == 200 && x <= 1400 && y > 800) {
    moveUp(-dy);
    y = y - dy;
  }
  else if ( (y == 800 || y == 1800) && x < 1400 ) {
    moveRight(dx);
    x = x + dx;
  }
  
}


// FUNCTION TO MOVE VERTICALLY: move up (dy > 0), move down (dy < 0)

void moveUp(float dy) {

  // Cable lengths according to the angles, in mm
  L2 = ( W - w ) / ( sin(theta1) * cos(theta2)/cos(theta1) + sin(theta2) );
  L1 = L2 * cos(theta2)/cos(theta1);

  // Variations in length in order to move vertically, in mm
  float dL1 = sqrt( pow(dy,2) + pow(L1,2) - 2*L1*dy*cos(theta1) ) - L1;
  float dL2 = sqrt( pow(dy,2) + pow(L2,2) - 2*L2*dy*cos(theta2) ) - L2;

  // Angles of rotation of the drums, in rad
  float dphi1 = dL1/r;
  float dphi2 = dL2/r;

  // For sixteenth stepping: 1 pulse = 1/16 step, and 3.6° = 1 step
  int npulse1 = round( 16/3.6 * 360/(2*PI) * dphi1 );
  int npulse2 = round( 16/3.6 * 360/(2*PI) * dphi2 );

  // Define the direction of rotation

  if (npulse1 > 0) { // i.e. dL1>0 -> go down
    digitalWrite(dirPin1, LOW);
  }
  else if (npulse1 < 0) { // i.e. dL1<0 -> go up
    digitalWrite(dirPin1, HIGH);
    npulse1 = -npulse1;
  }

  if (npulse2 > 0) { // i.e. dL2>0 -> go down
    digitalWrite(dirPin2, LOW);
  }
  else if (npulse2 < 0) { // i.e. dL2<0 -> go up
    digitalWrite(dirPin2, HIGH);
    npulse2 = -npulse2;
  }

  // Move

  for (int i = 1; i <= max(npulse1, npulse2); i++) {
    if (i <= npulse1) {
      digitalWrite(stepPin1, HIGH);
    }
    if (i <= npulse2) {
      digitalWrite(stepPin2, HIGH);
    }
    delay(3); // ms
    digitalWrite(stepPin1, LOW);
    digitalWrite(stepPin2, LOW);
    delay(3); // ms
  }
  
}


// FUNCTION TO MOVE HORIZONTALLY: move right (dx > 0), move left (dx < 0)

void moveRight(float dx) {

  // Cable lengths according to the angles
  L2 = ( W - w ) / ( sin(theta1) * cos(theta2)/cos(theta1) + sin(theta2) );
  L1 = L2 * cos(theta2)/cos(theta1);

  // Variations in length in order to move horizontally
  float dL1 = sqrt( pow(dx,2) + pow(L1,2) + 2*L1*dx*sin(theta1) ) - L1;
  float dL2 = sqrt( pow(dx,2) + pow(L2,2) - 2*L2*dx*sin(theta2) ) - L2;

  // Angles of rotation of the drums
  float dphi1 = dL1/r;
  float dphi2 = dL2/r;

  // For sixteenth stepping: 1 pulse = 1/16 step, and 3.6° = 1 step
  int npulse1 = round( 16/3.6 * 360/(2*PI) * dphi1 );
  int npulse2 = round( 16/3.6 * 360/(2*PI) * dphi2 );

  // Define the direction of rotation

  if (npulse1 > 0) { // i.e. dL1>0 -> go right
    digitalWrite(dirPin1, LOW);
  }
  else if (npulse1 < 0) { // i.e. dL1<0 -> go left
    digitalWrite(dirPin1, HIGH);
    npulse1 = -npulse1;
  }

  if (npulse2 > 0) { // i.e. dL2>0 -> go left
    digitalWrite(dirPin2, LOW);
  }
  else if (npulse2 < 0) { // i.e. dL2<0 -> go right
    digitalWrite(dirPin2, HIGH);
    npulse2 = -npulse2;
  }

  // Move

  for (int i = 1; i <= max(npulse1, npulse2); i++) {
    if (i <= npulse1) {
      digitalWrite(stepPin1, HIGH);
    }
    if (i <= npulse2) {
      digitalWrite(stepPin2, HIGH);
    }
    delay(3); // ms
    digitalWrite(stepPin1, LOW);
    digitalWrite(stepPin2, LOW);
    delay(3); // ms
  }
  
}

The two codes can be downloaded below. The 'Stepper_Servo' file corresponds to the first code and the 'Moving_Code' file corresponds to the second one. An additional code is also provided. This 'stepper_test' code allows making a stepper turn without a CNC shield using a breadboard circuit and has been used to verify the correct functioning of the steppers.

The two subsystems are put together by using threaded bars that interconnect the MDF plates on which the different subsystems are mounted. The Arduino board can then be mounted and the CNC shield placed on top of this. After doing this, the electrical connections to the different systems can be put in place on the CNC board. The H-bridge can also be installed and the breadboard with the voltage reduction can be put in place. When the necessary connections are made, the electronics can be enclosed in a box and the side plates can be placed to close the robot. Finally, when the code is uploaded to the Arduino and the connections to the power supply are made, the robot is ready to be started.

In order to start the robot, the wires meant for the movement of the robot first need to be connected to the top of the whiteboard. After this, the wire used to feed the Arduino logical circuit can be connected with an adapter from a power outlet. The other cables are used to power the motors and should be connected to a power supply that can provide up to 5 A at 12 V. When the power supply is turned on, the robot will start moving upwards.

Important to note is that when the power is turned off, the robot will fall down since no holding torque will be produced in the steppers anymore. Be sure to catch the robot to prevent damage to the device.

The biggest problem with the robot was the torque that the steppers provided. Getting the maximum amount of torque from the datasheets from the steppers proved very challenging. This resulted in a difference between the torque provided and the torque needed to lift the robot. Because of this, the robot can only lift itself when both cables are straight above it. The robot is still very heavy. Some of the components used (threaded bars, cleaning rollers, ...) can be modified to make the robot lighter and thus help achieve better performance.

If the robot would be improved further and more time was provided a gearbox should be installed that implements a larger gear reduction to the robot. This way a sufficient amount of torque would be provided when the cables are at an angle. Unfortunately, full movement over the window could not be achieved due to the problems with the torque. If a gearbox would be added this might still be feasible.

Another possible addition could be a sensor to determine the place of the robot on the window and provide a home searching capability. This way the robot does not need to be placed in a specific location before starting up. This can be achieved by using encoders to determine the angles of the cables and therefore the position of the robot.

When it is known in advance how far up the robot has to move the number of turns required could be calculated in the program and this way the robot would know when to stop and go down again. Some code related to this was provided but could not be tested due to a lack of time.

In order to make the robot more sustainable recycled materials could be used. Recycled wood can be used and the plastics could be chosen from a recycled origin. PLA is a good plastic for this since it is thermoplastic and can be easily melted down again and recycled.

Another way to make the robot more sustainable would be by adding batteries and solar panels to it. This way the robot can produce its own energy from a sustainable energy source.

The following materials are needed to build the robot:

• 1x Arduino UNO
• 1x CNC shield
• 2x stepper drivers DRV8825 (or A4988)
• 2x servo motors MG996R
• 2x stepper motors NEMA-17
• 1x lab source
• 1x H-bridge L298N
• 1x breadboard
• 5x diodes
• 2x fishing ropes (4 meters each)
• 8x ball bearings (8mm inner diameter, 22mm outer diameter)
• threaded bars: 4x (8mm x 130mm), 4x (8mm x 80mm)
• 2x smooth bars (6mm x 130mm)
• 2x paint rollers
• PLA filament (for 3D printing)
• MDF (4mm thickness)
• Plexiglas (4mm thickness)

The price of the material to build the robot is estimated at 181 euros. The details are provided in the following PDF document:

All of the people that worked on this project are electromechanical engineers enrolled in the shared VUB/ULB BRUFACE master:

• Stijn KINDT: Worked on the servo motors, their programming and electronics (voltage divider + control). Making the mechanical design (assembly + drawing of parts) and producing parts of the robot. Wrote the mechatronics report and made calculations at the development stage.
• Menthy DENAYER: Worked mainly on the initial calculations, research, mechanical design, 3D printing, and assembling of the robot.
• Louise MASSAGER: Worked mainly on the stabilization mechanism (cable guidance computation and principle), the movement mechanism (drums CAD), the robot structure (wood plates with joints CAD), the final adaptation of the robot (new plates, new spools and box containing the electronics) and editing of videos.
• Dinh-Hao NGUYEN: Worked on the stepper motors (programming and electronics), the movement mechanism computation (calculations and programming of the robot full movement) and the final adaptation of the robot (all the electronics adjustments).

All project files can be found in the following ZIP folder. The folder contains the assembly and the codes that were used to move the robot. It can be downloaded at the following link