Published August 7, 2023 © MIT

Never get your Hands dirty again with the Radar Shield2Go!

Don't touch a thing! Let Infineon's Radar Shield2Go do it for you. Learn how to automate a trash can with the XMC2Go and Arduino IDE!

IntermediateFull instructions provided8 hours650

Things used in this project

Hardware components

Infineon S2GO RADAR BGT60LTR11

Infineon XMC2GO - industrial microcontroller kit

Infineon S2GO HALL TLE4964-3M

MG995 Tower Pro Servo Motor (360°-continuous version)

The servo motor used in this project was continuous

Breadboard (generic)

RC Winch Servo Add-On

M2 Screw

To fasten the Servo in its position and to attach the Base of the Servo Tower with the Servo Tower (4x M2 screws come with the Servo)

M3 Screw 8mm

Comes with the RC Winch module

6V Power Supply

6V Power Supply used for the Servo Motor

Power Bank

A Power Bank with a Micro-USB Output with 5V for the XMC2Go

Software apps and online services

Arduino IDE

Hand tools and fabrication machines

3D Printer (generic)

Hot glue gun (generic)

Story

Are you one of those stack-and-dump enthusiasts who accumulate their junk next to them and throw it all away at once, just to avoid walking back and forth to the trash can? The problem with that is sometimes this junk stack you're carrying gets so high that you can't even see where the foot pedal is to open the lid, let alone the trash lid itself. Even if you could see the lid, you wouldn't want to get your hands dirty right? [Of course, this is a pure exaggeration but you know what they say "Exaggeration (Necessity formerly) is the mother of invention"! ]

Well, you don't have to get your hands dirty, because the red, light-hearted Radar Shield2Go is here for you. Why light-hearted you may ask? Because The second you approach it, it opens up (the trash lid) for you.

Don't believe me? Keep reading to discover how this was achieved using a Hall Switch Shield2Go, XMC2Go, and a Servo Motor with the help of the Arduino IDE. See the magic in action for yourself!

3D Design, Print, and Assembly

NOTE: The trash can used for this project might not be exactly like the ones you have, but the concept is quite similar. Feel free to adjust the 3D models accordingly to match the dimensions of the trash can you have (with e.g. Tinkercad).

We started by examining the trash can to find a potential design to lift the lid. Inside the trash can, it looks like this:

1 / 2 • Bird's-eye perspective inside trash can

As you can see there is a foot pedal attached to a rod (red circle) that pushes the lid when the pedal goes up (by pushing with your foot on the outer part of the pedal).

The idea is to place a servo motor somewhere in the blue-marked area and let it pull this pedal with the help of a winch add-on. When the pedal gets pulled, the lid gets pushed and opens up the trash lid.

Let's begin with the servo mounting. Here's what it looks like:

1 / 2 • Servo Base from different perspectives

TIP: This model takes some time to print (approximately 4-5 hours), so you might want to check out the XMC for Arduino post, the Hall Switch post, and the Radar Shield2Go post in the meantime because you'll need them later on.

Done already?! Print out the second part (Servo Base) which gets attached to the Servo Tower to stabilize it on top of the blue marked plastic rails (shown earlier in the pic):

1 / 2 • Base stabilizer from different perspectives

The next thing is to print out the RadarClip and the RadarHolder, they'll be used later:

1 / 3 • Radar Clip (Front: Left - Back: right)

In the meantime, you can start with the assembly of the Servo Tower:

NOTE: Assembly videos are also included with the 3D file in the attachments section.

Assembling Servo and mounting it on its Tower

After making sure the servo is in place, the winch add-on was also screwed to the servo motor (onto the rotor itself):

Adding the winch add-on to the assembly.

The winch rope is inserted through two dedicated holes in the servo add-on and is secured in place by an M3 screw (which comes with the add-on) that holds the add-on in place, ensuring that it stays firmly fixed.

Now, the Servo Tower is ready to be fastened to the Base printed earlier while aligning the plastic rails (the blue-marked area ) between them:

Fastening the tower to the base

NOTE: All screws, except for the M3x8mm winch screw, are M2 screws (the ones that come with the MG995 Tower Pro Servo).

After putting everything in place the setup looks like this:

Servo setup complete

The winch rope was then tied around and through the pedal hole where one end of the metal rod rests. This is actually of benefit because the rod squeezes the rope and ensures that everything is fixed in place.

The Radar Shield2Go (preferably with female headers) is meant to be hot glued inside its parking spot in the Radar Holder. Then Both the clip and the holder are meant to be hot glued together:

Radar Holder and Clip assembly

and then clipped onto the edge of the trash can (red highlighted edge in the picture above).

HINT: The holes on the side of the holder are intended for the jumper cables to pass through them and into the trash can, between the can itself and the actual trash compartment. This guides the cables down to the Servo Tower, where the breadboard and XMC2Go are positioned. Quiteajourney, right?!

Hardware Setup: Wiring and Arrangement

Now, the hard mechanical part is over so let's switch to the electrical part.

Theoretically, the idea is simple:

Approach the Radar Shield2Go
The Continuous Servo will turn as needed to open the trash can.
Keep turning until the Hall Switch (TLE4964-3MS2GO Breakout) detects a magnet on the rod, which is precisely positioned or calibrated to indicate the "Lid is open" state
Stop the motor and wait for a while or until no more motion is detected.
Then, turn the motor in the opposite direction to close the lid.

Where the XMC2Go acts as the brain of the project.

To make a long story short, this is the Wiring diagram of the whole project:

Wiring diagram of the project

Now, as far as the arrangement goes:

Radar goes into its dedicated 3D part (see3D Printing and Assembly)
The small Breadboard with the XMC2Go goes inside the trash (it can be attached to the side of the Servo Tower)
A Power Bank to supply 5V to the XMC2Go also goes inside the trash can (it can be positioned on top of the Servo Tower next to the Servo)
Servo motor into its dedicated spot (see 3D Printing and Assembly)
6V Power Supply somewhere near the Trash Can
Hot glue the TLE4964-3M Breakout-board inside the Lid Cover that opens and closes the trash lid, with the metal rod passing through (indicated by the red-marked area):

Position of Hall Switch breakout-board

The Radar Settings used were:

Minimum sensitivity: about 0.2-0.4m detection range (QS2: left potentiometer at left-most position)
Hold time: about 30s (QS3: right potentiometer about 90° CCW from its right-most position)

NOTE: Check out the Radar Shield2Go article to know how to adjust these settings.

Code

Now that everything is in place. All that is left to do, is to program the logic behind all of the Boards used above to communicate together and work correctly.

The code is located in the attachment section but to clarify some important aspects:

The Servo used here is the continuous version of the MG995 Tower Pro Servo Motor, meaning it won't stop at a specific angle, it keeps spinning until it's told to stop. This is what the function analogwrite_ms() is here for:

/*
@brief        ROTATES MOTOR CW OR CCW. TO ROTATE CW USE A PULSE BETWEEN 0.5 - 1.3 ms WITH 0.5 BEING THE FASTEST ROTATION POSSIBLE
TO ROTATE CCW USE A PULSE BETWEEN 1.5 - 2.5 ms WITH 2.5 BEING THE FASTEST ROTATION POSSIBLE
@param        ms IS THE PULSE DURATION IN MILLISECONDS
@return       TRUE IF EVERYTHING WENT ALRIGHT WITH THE analogWrite() FUNCTION (for error tracking purposes)
*/

analogwrite_ms(float ms);

NOTE: Maximum speeds were used in this project, and also recommended

This program also uses a StopWatch.h library to determine the duration of the Lid closing and if something went wrong with the Hall Switch, the motor should stop after a specific time (EmergencyStop).
The Code is designed to track the previous state and the current state and act accordingly. Mostly any action taken is triggered by this stateChanged() function:

/*
@brief    To track the state of the PD pin of the Radar S2Go
@param    void
@return   true if change in state,false if not.
*/

bool stateChanged()

Now the program works this way:

You start off in the NO_DIR (No motion detected) state. As soon as you power on the Radar (because motion is detected) you enter the DEPARTING state.
From NO_DIR to DEPARTING the lid doesn't have to open, so nothing to do here.
Now from DEPARTING you can go to NO_DIR or stay in DEPARTING, which in both cases there is nothing to do.

Until here, the lid is closed.

Or you could go to the APPROACHING state, in which the motor should spin to open up the trash lid tillOpen() while also starting the stopwatch.
From APPROACHING you go straight to DEPARTING (no other option) and if the time option is not commented out (line 96-107 in the code) then it would wait <waitingTime> ms for the motor to start spinning again but in the opposite direction (closing the lid) for the same amount of time it took to open the lid.
If the time option is commented out then the lid will stay open until it enters the NO_DIR state (where no motion is detected) where it will close.
unless it's interrupted by something APPROACHING (well, technically DEPARTING first then APPROACHING) then the motor will stop spinning and spin in the opposite direction to open up again.

Keep in mind that as long that there is motion and nothing is APPROACHING then the Radar is in the DEPARTING state.

Farewell

Before we say goodbye, first let's say goodbye to dirty hands because it's not gonna be a thing anymore.

As said before, the trash can used here is probably not gonna be the one everyone has but the concept is the same:

Radar for motion/phase detection
Servo for opening and closing
Hall Switch for position detection
XMC2Go (µC-Board) as the brains

Now the 3D files can also be adjusted or changed completely, but now you know the way.

There you have it! An auto trash can. I know it's fun and everything, but please do not abuse it and start throwing things away, especially plastic, just to see if it works.

This is a demo of the project

DISCLAIMER: The video shown above is for demonstrational purposes. You don't need to actually wave your hand in front of it, you can just approach it by any means even from the side. This is a 60GHz Radar, it will sense when you're approaching!

Stay clean, stay safe, and Goodbye!

Schematics

Code

Trash Opener

#include <StopWatch.h>
#include <bgt60-ino.hpp>
/* Include Arduino platform header */
#include <bgt60-platf-ino.hpp>


#ifndef TD
#define TD  4  
#endif

#ifndef PD
#define PD  8
#endif

// #define BUTTON1 24
#define pwm 1 //8 or 1 on XMC2Go //9 On relax Kit
#define freq 50
#define hall 5


/* Create radar object with following arguments:
 *  TD : Target Detect Pin
 *  PD : Phase Detect Pin */
Bgt60Ino radar(TD, PD);

//Init with no Motion to record new states
// Bgt60::Motion_t motion            = Bgt60::NO_MOTION  ; No need to add motion as no it is interpreted as departing if not approaching and TD is low
Bgt60::Direction_t curdirection   = Bgt60::NO_DIR     ;
Bgt60::Direction_t prevdirection  = Bgt60::NO_DIR     ;

StopWatch stopwatch   ;
// StopWatch stopwatch_c ; //Stopwatch for closing

bool isOpen   = false;
bool closing  = false;

uint32_t waitingTime=20000;

uint32_t time = 0;



void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  //enable stopwatch for inconsistency of hold time, as radar is very sensitive!
  stopwatch.setResolution(StopWatch::MILLIS);
  // stopwatch_c.setResolution(StopWatch::MILLIS);

  // Init Radar
  radar.init();

  // Set pinModes for PWM Pin and Hall-Sensor Pin
  pinMode(pwm,OUTPUT);
  pinMode(hall,INPUT);

  //Sets the analogwrite frequency to 50Hz (20 ms window for the Servo)
  setAnalogWriteFrequency(pwm,freq);
 
}

void loop() {
  // put your main code here, to run repeatedly:
  
  //program refresh rate
  delay(20);

  Error_t err = radar.getDirection(curdirection);

  if(err==OK)
  {
    if(stateChanged()== true)
    {
      if(prevdirection==Bgt60::NO_DIR)
      {
        
        if(curdirection==Bgt60::DEPARTING)
        {
          Serial.println("from no_dir to departing: Motor do nothing here");
          ;
        }
        else
        {
          Serial.println("from no_dir to approach or no_dir is not a possible transition, departing first"); //do nothing
          ;

        }
      }

      else if(prevdirection==Bgt60::APPROACHING)
      {
        if(curdirection==Bgt60::DEPARTING)
        {
          Serial.println("from approach to departing: Motor wait for 20 secs and close if its open");
          
          if(isOpen==true) //Comment out this condition if you want to purely rely on the Radar to determine when to close
          {
            delay(waitingTime); //wait for 20 secs

            closing=true;
            analogwrite_ms(2.5);
            stopwatch.start();
          }
          else
          {
            ; //do nothing because closing will not be true if i was approaching first
          }
          
        }
        
        else
        {
          Serial.println("There is no other state possible other than DEPART")
          ;
        }
      }

      else //if previously departing
      {
        if(curdirection==Bgt60::NO_DIR)
        {
          Serial.println("from depart to no_dir: close the lid if it's still open"); //lid would probably be closed if delay < TD hold time, but if(isOpen==true) close it
          
          if(isOpen==true)
          {
            closing=true;
            analogwrite_ms(2.5);
            stopwatch.start();
          }
          else
          {
            ; //do nothing if its already closed
          }
        }

        else //APPROACHING
        {
          if(isOpen==false)
          {
            Serial.println("Open Sesame!");
            closing=false;
            analogwrite_ms(0.5);
            stopwatch.start();
            
            tillOpen();
            analogwrite_ms(0);
          }

          else if(closing==true)
          {
            Serial.println("from depart to approaching: Motor stop and rotate for same duration it was closing");

            analogwrite_ms(0);

            delay(100);
            
            closing=false;

            analogwrite_ms(0.5);
            stopwatch.start();
            
            tillOpen();
            analogwrite_ms(0);
          }

          else
          {
            ;
          }
        }
        
      }
    }
    else //if previous direction is same as current direction
    {
      if(closing==true)
      {
        Serial.println("Normal Closing!");

        if(stopwatch.elapsed()>=time || stopwatch.elapsed()>=2000) //by testing out the full speed Servo, it won't take more than two seconds to close the lid
        {
          Serial.print("Elapsed time: ");
          Serial.println(stopwatch.elapsed());
          analogwrite_ms(0);

          stopwatch.stop();
          stopwatch.reset();
          
          time=0;
          closing=false;
          isOpen=false;
        }
        
      }
      else
      {
        ;
      }
    }
    prevdirection=curdirection;
  }

  

}
//-----------END OF LOOP()-------------------------------------------------




//-----------CUSTOM FUNCTIONS----------------------------------------------

/*
  @brief  This function is basically the endstop for the lid. When the TLE4964 Hall Sensor notices a magnet nearby it gives a LOW signal to the XMC2Go

  @param  void

  @return void
*/
void tillOpen()
{
  while(true)
  {
    if(digitalRead(hall)==LOW)
    {
      isOpen=true;
      Serial.println("I should Stop now!");
      time=stopwatch.elapsed();
      Serial.print("to open:");
      Serial.println(time);
      if(time==4000){ //if motor is running for 4 seconds emergency stop!
        break;
      }
      stopwatch.stop();
      stopwatch.reset();
      break;
    }
    else
    {
      continue;
    }
  }
}


/*
    @brief        ROTATES MOTOR CW OR CCW. TO ROTATE CW USE A PULSE BETWEEN 0.5 - 1.3 ms WITH 0.5 BEING THE FASTEST ROTATION POSSIBLE
                                         TO ROTATE CCW USE A PULSE BETWEEN 1.5 - 2.5 ms WITH 2.5 BEING THE FASTEST ROTATION POSSIBLE
    
    @param        ms IS THE PULSE DURATION IN MILLISECONDS
    
    @return       TRUE IF EVERYTHING WENT ALRIGHT WITH THE analogWrite() FUNCTION (for error tracking purposes)

*/
bool analogwrite_ms(float ms)
{
  int window = 1000 / freq;
  int duty_c=ceil((ms / window) * getAnalogWriteMaximum());
  int ret=analogWrite(pwm,duty_c);

  Serial.print("ANALOG WRITTEN: ");
  Serial.println(duty_c);
  Serial.print("RETURN CODE: ");
  Serial.println(ret);

  if(ret==0){return true;}
  else{return false;}
}


/*
  @brief    To track the state of the PD pin of the Radar S2Go

  @param    void

  @return   true if change in state,false if not.
*/
bool stateChanged(){
  bool dirChanged = false;

  if(prevdirection != curdirection)
    dirChanged = true;
  else
    dirChanged = false;

  return dirChanged;
}
//--------------END OF CUSTOM FUNCTIONS-------------------------------------

Never get your Hands dirty again with the Radar Shield2Go!

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

3D Design, Print, and Assembly

Hardware Setup: Wiring and Arrangement

Code

Farewell

Custom parts and enclosures

3D Files with Assembly

Schematics

Wiring Diagram

Code

Trash Opener

Infineon Radar BGT60LTR11 Arduino Library

Credits

Infineon Team

Comments

Embed the widget on your own site

Never get your Hands dirty again with the Radar Shield2Go!

Never get your Hands dirty again with the Radar Shield2Go!

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

3D Design, Print, and Assembly

Hardware Setup: Wiring and Arrangement

Code

Farewell

Custom parts and enclosures

3D Files with Assembly

Schematics

Wiring Diagram

Code

Trash Opener

Infineon Radar BGT60LTR11 Arduino Library

Credits

Infineon Team

Comments

Related channels and tags