When one gets a Nespresso coffee machine, the first question that comes to mind is how to organize the different colors of coffee capsules. While chatting with friends about the existing solutions to this "problem", we have been challenged to build an automatic coffee capsule dispenser. Of course, we could not resist...
We'd better be frank with you: the aim is simply to show off a little when friends come over for a coffee at home. This dispenser is more expensive, more complex, and probably less convenient than a simple bowl with all the capsules mixed up.
This automatic coffee capsule dispenser uses an old Android tablet and several servomotors controlled by a Yocto-Servo. The tablet runs a native application listing the available coffees. When the coffee is selected, the application activates a servomotor that frees a capsule of the selected coffee.
Here is our automatic coffee capsule dispenser
The mechanics: the dispenser
The dispenser is made of 5 distribution rails. The rails are positioned vertically. The capsules are inserted at the top of the rails and come out at the bottom. Each distribution rail is activated by a single servomotor and can contain up to 10 capsules. The 5 rails are connected to the 5 Yocto-Servo outputs.
The main difficulty in this project was the distribution rail design, more particularly the mechanism enabling the dispenser to free one capsule at a time.
At the bottom of the rail, there is a cam that a servomotor moves. In idle state, the cam blocks the end of the rail and prevents the capsules to come out. When you activate the servomotor, the cam rotates by 150 degrees, frees the bottom capsule while blocking the other ones.
| When the cam rotates, it frees only one capsule | ||
When the capsule has fallen, the cam comes back to its idle state and all the remaining capsules move down by one position.
A detailed view of a distribution rail
You can download the files needed to build this capsule dispenser on Thingiverse.
The connection: USB or Wifi
In our case, we used an Acer A200 tablet that has both a USB port and a charging socket. Therefore, we connected the Yocto-Servo directly on the tablet USB port with a USB cable that is a meter long. The Yocto-Servo is powered directly by the tablet which is powered through its charging cable.
In our example, we used a USB connection
However, most recent tablets use the USB port to charge. In this case, there are two options: The first one is to use a Y cable available from some providers.
The second is to use a YoctoHub to connect the Yocto-Servo to your local network. The application then communicates with the Yocto-Servo by using the local network instead of a USB connection. The application code doesn't change. You must simply give the IP address of your YoctoHub as parameter instead of the "USB" keyword to the YAPI.RegisterHub() method.
You can also use a Wifi connection
The software: the Android application
The Android application is very simple and draws largely from the FragmentStatePagerAdapter example of the Android documentation. The application displays several pages presenting the available coffees. Each page contains a button freeing a capsule from the dispenser.
A screenshot of the application
All the code controlling the dispenser is gathered in the DispenserInterface class. This class is a singleton implementing 4 methods:
- Get(Context ctx) returns the singleton
- startUsage() initializes the connection with the Yocto-Servo
- stopUsage() frees the resources used for the connection with the Yocto-Servo
- distributeCapsule(int index) sends the commands to the Yocto-Servo to distribute a capsule
The startUsage() and distributeCapsule(int index) methods trigger a communication with the module which may provoke a delay (for instance if the Yocto-Servo is disconnected). Therefore, the code for these two methods is run as a background task using an AsyncTask.
Note: As our module is always connected by USB, we could run the startUsage method from the main thread, but this would freeze the interface during the code execution. In any way, under Android, it is recommended to run IO operations in the background to keep the application reactive.
The code freeing a capsule contains a YServo object which enables interaction with one of the Yocto-Servo outputs. It changes the position of the servomotor, waits for a second, and restores the previous position. Instead of directly using the set_position method, we use the move command allowing us to define the number of milliseconds to reach the final position. This makes the cam movement smoother.
...
private class DistributeCapsule extends AsyncTask<Integer, Void, String> {
@Override
protected String doInBackground(Integer... params) {
int index = params[0];
String hwid = String.format("%s.servo%d", _serial, index+1);
YServo servo = YServo.FindServo(hwid);
try {
servo.move(UP_POSITION, 300);
Thread.sleep(1000);
servo.move(DOWN_POSITION, 300);
} catch (YAPI_Exception e) {
e.printStackTrace();
return e.getLocalizedMessage();
} catch (InterruptedException e) {
e.printStackTrace();
}
return null;
}
@Override
protected void onPostExecute(String error) {
if (error != null) {
Log.e("YAPI", error);
_lastError = error;
}
}
}
public synchronized void distributeCapsule(int tubeIndex) {
new DistributeCapsule().execute(tubeIndex);
}
...
}
The rest of the code is not detailed in this article because it is either code that we detailed in previous posts, or code to manage the interface. The Android Studio project of the application is available on GitHub for the more curious among you.
Conclusion
| Show off time! | ||
We are not going to lie to you: this dispenser wasn't built in 5 minutes. Design, 3D printing, plexiglass cutting, and assembly took several evenings :-) But if we put aside the mechanical part, the remainder took only a few hours. The connections are obvious (we didn't even need a soldering iron), and the code managing the servomotors fits in a 150 line class. This project is a good example of what we try to do at Yoctopuce: provide modules that are easy to use so that the user doesn't lose time on the electronic part and can concentrate on everything else.
