An Arduino-powered useless machine built inside a vintage cigar box: switch it on, the Peronist march starts playing, a mechanical arm emerges, switches itself off, and the music stops.
Peron/Peroff is a small electronic-art object based on the classic idea of a useless machine: a device whose principal action is to undo the action performed by its user.
The build combines an Arduino, a high-torque servo, a DFPlayer audio module, a 3 W speaker, a physical toggle switch, a 3D-printed arm, an old cigar box, and an image of Eva Perón.
Its behavior is deliberately simple:
User flips switch ON
│
▼
Peronist march starts / resumes
│
▼
Wait 3 seconds
│
▼
Servo arm emerges
│
▼
Switches itself OFF
│
▼
Arm returns
│
▼
Music pauses
Then everything waits for somebody to turn it on again.
- 🔌 Classic self-switching useless-machine behavior
- ⚡ Arduino Nano controller
- 💪 MG996-class high-torque servo
- 🎵 DFPlayer audio playback
- 💾 microSD audio storage
- 🔊 4 Ω / 3 W speaker
- 🎚️ Physical toggle switch
- 🦾 Custom 3D-printed switching arm
- 📦 Built into a recycled cigar box
- 🖼️ Eva Perón imagery
- 🎶 Peronist march audio
- ⏯️ Music pauses and resumes across activations
- 🧠 Very small state machine
- 🎭 Electronic-art / absurd-machine approach
- 🛠️ Source code published on GitHub
A normal machine is expected to transform an input into a useful output:
Input
│
▼
Machine
│
▼
Useful result
A useless machine reverses that expectation:
User switches machine ON
│
▼
Machine acts
│
▼
Machine switches itself OFF
│
▼
Original state restored
The entire purpose of the mechanism is therefore the negation of its own activation.
Peron/Peroff adds sound, imagery, recycled materials, and a specific Argentine visual identity to that familiar mechanical joke.
The title combines:
Perón
with the two states of a switch:
ON
OFF
producing:
PER-ON
PER-OFF
or:
The wordplay becomes literal because the machine alternates continuously between those two states.
The user sees a toggle switch on top of the box.
When the switch is activated:
PERO N
ON
the Arduino detects the change.
The audio starts and, after a short delay, a servo moves the mechanical arm toward the switch.
switch
│
▼
[ ON ]
▲
│
│
servo arm
The arm pushes the switch back:
[ ON ] → [ OFF ]
and then retracts.
The audio is paused.
The machine has returned itself to its initial state.
The current project logic follows this sequence:
Read switch
│
▼
switch == LOW?
│
┌──┴───┐
│ │
No Yes
│ │
│ ▼
│ Audio already started?
│ │
│ ┌───┴────┐
│ │ │
│ No Yes
│ │ │
│ ▼ ▼
│ Start Resume
│ MP3 playback
│ │ │
│ └────┬───┘
│ ▼
│ wait 3 s
│ │
│ ▼
│ Servo → 180°
│ │
│ wait 1 s
│ │
│ ▼
│ Servo → 0°
│ │
│ ▼
│ Pause MP3
│ │
│ wait 2 s
│ │
└────────┘
One particularly useful detail in the implementation is that the music does not necessarily restart from the beginning every time.
The source maintains:
isPlayingto distinguish the first activation from later ones.
On the first activation:
execute_CMD(0x0F, 0x01, 0x02);starts playback.
On later activations:
play();resumes playback.
After the mechanical arm finishes its movement:
pause();stops the music at its current position.
The experience therefore becomes:
Turn ON
→ hear fragment A
→ machine turns OFF
Turn ON again
→ hear fragment B
→ machine turns OFF
Turn ON again
→ hear fragment C
→ ...
rather than repeatedly hearing only the beginning of the recording.
The core sequence documented in the current implementation is:
delay(3000);
servoMotor.write(180);
delay(1000);
servoMotor.write(0);
pause();
delay(2000);So the approximate behavior is:
| Stage | Time |
|---|---|
| Music before arm movement | 3 s |
| Arm extended | 1 s |
| Final pause before next interaction | 2 s |
The servo positions are:
Rest: 0°
Extended: 180°
These values may need adjustment depending on the exact servo horn and geometry of the 3D-printed arm.
The main loop reads the physical switch:
int butValue = digitalRead(switchPin);and considers the machine activated when:
butValue == 0or:
LOW
Conceptually:
Switch
│
▼
digitalRead()
│
▼
LOW
│
▼
Start machine sequence
The physical switch is simultaneously:
- the user's input
- the state of the machine
- the mechanical target of the servo
That makes the interface unusually economical.
The build uses a strong MG996-class servo motor.
The servo drives a custom arm that reaches from inside the cigar box toward the external switch.
Arduino
│
▼
Servo signal
│
▼
MG996
│
▼
3D-printed arm
│
▼
Toggle switch
The arm only needs two principal positions:
0° → hidden / resting
180° → switch activation
Actual angles depend on the enclosure geometry.
The custom arm is available on Thingiverse:
Peron Peroff useless machine — Thingiverse
The arm converts the servo's rotation into the physical movement required to operate the switch.
The design can also be modified for:
- a different switch
- another servo horn
- a smaller box
- a larger enclosure
- different servo geometry
Instead of printing the complete machine body, the original project uses an:
old cigar box
as the enclosure.
The box contains:
Arduino Nano
DFPlayer
microSD
servo
speaker
wiring
while the exterior provides:
switch
image
servo-arm opening
This gives the machine a physical character quite different from a conventional plastic electronics enclosure.
The original machine uses a postcard featuring Eva Perón, obtained from the Museo Evita.
This image forms the top surface of the object together with the switch and mechanical arm.
The electronics are therefore hidden underneath an intentionally simple visual composition:
┌───────────────────────────┐
│ │
│ Eva Perón image │
│ │
│ ON/OFF │
│ switch │
└───────────────────────────┘
Audio playback is handled by a serial MP3 player module.
The detailed Hackster build identifies it as a:
DFPlayer Mini
The current repository README refers more generally to a:
Dfplayer
module.
The player provides:
- microSD storage
- MP3 decoding
- serial commands
- direct speaker support
- play
- pause
- resume
- track selection
Architecture:
Arduino Nano
│
│ serial commands
▼
DFPlayer
│
▼
microSD
│
▼
MP3 audio
│
▼
4 Ω / 3 W speaker
The repository currently contains:
001.mp3
The project documentation identifies the audio used in the installation as the Peronist march.
Repository:
PeronPeroff/
├── 001.mp3
├── README.md
└── peronperoff.ino
When preparing the microSD card, follow the DFPlayer file/folder naming convention expected by the sketch.
The source uses a low-level DFPlayer command:
execute_CMD(0x0F, 0x01, 0x02);so verify the final microSD directory and file numbering against the particular DFPlayer module being used.
| Qty | Component | Purpose |
|---|---|---|
| 1 | Arduino Nano R3 | Main controller |
| 1 | MG996-class servo motor | Operates the switch |
| 1 | DFPlayer Mini / compatible module | MP3 playback |
| 1 | microSD card | Audio storage |
| 1 | 4 Ω / 3 W speaker | Audio output |
| 1 | Toggle switch | User input and mechanical target |
| 1 | Resistor | DFPlayer / interface circuit |
| 1 | 3D-printed arm | Servo actuator |
| 1 | Cigar box | Enclosure |
| 1 | Eva Perón postcard / image | Visual element |
The classic Arduino Nano is based on the ATmega328P.
Relevant specifications include:
- 8-bit AVR MCU
- 16 MHz
- 32 KB Flash
- 2 KB SRAM
- digital I/O
- PWM
- UART
- SPI
- I²C
- compact form factor
Official documentation:
The computational requirements of Peron/Peroff are minimal:
read one switch
control one servo
send DFPlayer commands
maintain one state flag
so the Nano is more than sufficient.
An MG996-class servo can draw substantially more current than an Arduino Nano I/O pin or onboard regulator is designed to provide.
For reliable operation, use an appropriate power source for the servo.
Conceptually:
External 5–6 V supply
│
├──── Servo V+
│
└──── Arduino / servo common GND
Arduino signal pin
│
└──── Servo signal
The grounds must normally be common so the servo-control signal has the correct reference.
Do not power a high-current servo directly from an Arduino GPIO pin.
Before operating the complete machine, test the servo without the switch in place.
Start with conservative angles:
servoMotor.write(0);and gradually increase the second position until the arm reliably operates the switch.
Avoid forcing the servo against the mechanical stop.
An overextended arm can:
- stall the servo
- draw excessive current
- strip servo gears
- break the printed arm
- damage the switch
The project is intentionally small.
The central section is essentially:
int butValue = digitalRead(switchPin);
if (butValue == 0) {
if (isPlaying == 1) {
play();
}
else {
execute_CMD(0x0F, 0x01, 0x02);
isPlaying = 1;
}
delay(3000);
servoMotor.write(180);
delay(1000);
servoMotor.write(0);
pause();
delay(2000);
}The complete machine is therefore based on three operations:
switch detection
+
servo movement
+
MP3 playback
There is no network service, external computer, database, cloud API, or operating system involved.
Without remembering playback state, every activation could restart the audio.
Instead, the project uses:
isPlayingas a simple state variable.
isPlaying = 0
│
▼
First activation
│
▼
Start audio
│
▼
isPlaying = 1
Every later activation can then call:
play();instead of starting the track again.
This small software decision significantly changes the behavior of the artwork.
The term Macchine Inutili is strongly associated with Italian artist and designer Bruno Munari, who began developing his Useless Machines in the early 1930s.
Munari's works were light kinetic constructions whose purpose was aesthetic rather than productive.
They challenged the conventional assumption:
machine = utility
and replaced it with:
machine = movement / form / play / art
Historical resource:
Bruno Munari — Macchine Inutili
Museums continue to preserve examples of these works:
Macchina inutile — Museo d'Arte Contemporanea di Villa Croce
The specific mechanism familiar today as the:
useless box
is somewhat different from Munari's kinetic works.
Its characteristic behavior is:
human turns switch on
│
▼
mechanical arm appears
│
▼
arm turns switch off
│
▼
arm disappears
That form is commonly associated with an idea by Marvin Minsky from his Bell Labs period in the early 1950s.
Over time, makers have produced countless variations involving:
- multiple arms
- angry boxes
- lights
- sounds
- elaborate mechanisms
- different enclosures
- character-based designs
Peron/Peroff combines that self-switching mechanism with the broader artistic tradition of the useless machine.
A conventional useless box has one interaction:
ON
↓
OFF
Peron/Peroff adds an additional temporal layer:
ON
↓
music
↓
mechanical intervention
↓
OFF
↓
silence
Because playback can resume on the next activation, repeated interactions reveal more of the recording.
The machine therefore establishes a simple conflict between two actions:
The user keeps starting the machine.
The machine keeps stopping itself.
git clone https://github.com/ronibandini/PeronPeroff.git
cd PeronPeroffDownload:
Select:
Tools
→ Board
→ Arduino AVR Boards
→ Arduino Nano
Depending on the particular Nano or clone, it may also be necessary to choose:
ATmega328P
or:
ATmega328P (Old Bootloader)
Connect:
Signal → Arduino pin configured in peronperoff.ino
V+ → suitable servo power supply
GND → common ground
Verify motion before attaching the printed arm.
Insert a microSD card containing the audio file in the folder/file arrangement expected by the sketch.
The repository includes:
001.mp3
as the reference audio asset.
The original build uses:
4 Ω
3 W
speaker hardware.
Connect it according to the requirements of the particular DFPlayer module.
Wire the toggle switch to the digital input configured as:
switchPinThe current logic treats:
LOW
as the activated state.
Open:
peronperoff.ino
compile, and upload it to the Arduino Nano.
Arduino C++ firmware implementing:
- switch detection
- audio start/resume
- DFPlayer commands
- playback state
- servo movement
- audio pause
Audio asset associated with the installation.
Original project summary and links.
The complete machine can be seen operating here:
The servo arm is available on Thingiverse:
Peron Peroff useless machine — Thingiverse
The model is also indexed by 3D-model search services such as Yeggi under:
art
dfplayer
servo
sound
useless machine
A 2025 profile of Roni Bandini and his machines explicitly discusses Peron-Peroff, describing it as a device with Eva Perón's image that plays the Peronist march when activated and then quickly switches itself off.
Creó un Furby con la voz de Borges y otros aparatos inspirados en libros — El Destape
The project was published on Hackster on November 20, 2020.
The project page documents:
- Arduino Nano R3
- MG996 servo
- DFPlayer
- microSD card
- 4 Ω / 3 W speaker
- switch
- resistor
- cigar box
- 3D-printed arm
- MP3 playback
- servo sequence
- source-code behavior
Peron/Peroff Useless Machine — Hackster.io
The original project article was published on November 20, 2020.
It documents the physical materials behind the machine:
cigar box
Eva Perón postcard
servo
Arduino
DFPlayer
resistor
Peronist march MP3
speaker
switch
C++ code
Peron/Peroff useless machine — Medium
An early video of the machine generated a large discussion on r/argentina in November 2020.
The thread also produced discussion around the Peron/Peroff name and the idea of making the audio continue from the point where the previous activation stopped.
Argentina, la máquina que se apaga sola — Reddit
A second community post followed in December 2020.
Peron Peroff useless machine — Reddit
Ecosyste.ms currently indexes the repository under topics including:
arduino
bruno-munari
dfplayermini
dfrobot
servo-motor
useless-machine
DFPlayer Mini projects — Ecosyste.ms
A large archive dedicated to Bruno Munari documents his development of Macchine Inutili beginning in the 1930s.
Bruno Munari — Macchine Inutili
The museum collection includes documented examples of Munari's Macchina inutile.
Macchina inutile — Musei di Genova
Peron/Peroff belongs to a broader series of machines built around absurdity, technological jokes, discarded objects, alternative ideas of utility, literature, history, and unconventional electronics.
More projects and context are collected in:
- Arduino Nano
- Arduino Servo library
- DFPlayer Mini — DFRobot
- Bruno Munari — Macchine Inutili
- Useless machine — overview
- Servo arm — Thingiverse
Other projects by Roni Bandini combining electronic art, recycled objects, unusual interfaces, and machines with unconventional purposes.
A discarded Olivetti calculator transformed into an electronic-art installation using an Arduino UNO R4 Minima, six-digit LCD, and the original printer mechanism.
Like Peron/Peroff, it takes an existing object and gives it a completely different behavior.
A discarded Furby transformed into a literary electronic automaton.
Another project where a familiar object becomes the physical shell for a new machine.
A full-scale ESP8266-controlled recreation of the Westinghouse Elektro robot using recycled metal, audio, motors, smoke, and mechanical movement.
Another project combining historical references, physical construction, sound, and embedded control.
github.com/ronibandini/elektro
The current GitHub repository does not contain an explicit software license file.
Unless a license is added, normal copyright rules apply to the source and repository assets.
Roni Bandini
Maker, AI developer, electronic artist and writer.
- 🐙 GitHub: @ronibandini
- 💼 LinkedIn: Roni Bandini
- 📸 Instagram: @ronibandini
- 🐦 X: @RoniBandini
- ✍️ Medium: bandini.medium.com
- 🛠️ Hackster: Roni Bandini
- 🔧 Hackaday.io: Roni Bandini
Buenos Aires, Argentina.