DIY Robots in Architecture was a four-day intensive workshop during the Detmolder Räume week at the Detmold School of Design, TH OWL. I led it with Yusuf Aykin and Prof. Hans Sachs for sixteen participants drawn from all of the design courses — architecture, interior architecture and the integrated design master.
No prior programming or robotics experience was required, which was the point. Students built, assembled, programmed and iterated their own robotic tools and vehicles out of low-cost, open-source hardware: Arduino-powered rovers at one end of the room, self-assembled robotic arms at the other. The workshop ran on a DIY and prototyping ethos, using cheap and accessible technology as a way into automated design processes rather than as an end in itself.
By the end of the week a large proportion of the bachelor students were programming independently — from no code at all on Monday. That, more than any one machine that drove across a table, is what the four days were for.
- Type
- Workshop — taught
- Role
- Workshop lead, with Yusuf Aykin and Hans Sachs
- When
- May 2026, Detmolder Räume week
- Module
- BA6010 · 4 ECTS · 2 SWS
- Participants
- 16, from all design disciplines
- Where
- Detmold School of Design, TH OWL
- Hardware
- Arduino, open-source kits, self-assembled arms
How the four days ran
Each day paired a short input with a long build. Students started from a working example — a motor that turns, a sensor that reads — and then changed it until it did something they had chosen themselves. Debugging was done at the table, out loud, which is how the room taught itself faster than we could have taught it.
Because the hardware was cheap and open, nobody was afraid of it. A broken part was a part you replaced, not a piece of laboratory equipment you had to apologise for — and that is what let people who had never written a line of code take a machine apart on the second morning.
What came out of it
- Arduino-powered rovers
- Self-assembled robotic arms
- Custom end-effectors
- Sensor-driven behaviours
- Students programming independently
Code a beginner can hold
The kits arrive with example code written for people who already know electronics: pin numbers, servo objects and wiring details, all in the same file as the part a student actually wants to change. So each kit — the smart home, the robot arm, the smart farm and the quadruped — got one modular sketch that splits the two apart.
Everything about the hardware sits in a class at the top, under a comment that says not to touch it. What is left is loop(): a short list of plain commands like arm.openClaw() and home.openDoor(), each on its own line with a comment, and a line inviting the student to change the numbers.
One sketch per kit
- Smart home
- Robot arm
- Smart farm
- Quadruped
void loop() {
/*
* PASTE SNIPPETS BELOW THIS LINE
* To change how the robot moves, tweak the numbers inside the ( ).
*/
arm.moveBase(90); // Move the base to the center
delay(1000); // Wait for 1 second
arm.openClaw(); // Open the gripper
delay(1000);
arm.closeClaw(); // Close the gripper
delay(1000);
// TRY THIS: Change the numbers above or add your own movements!
}
Safe to get wrong
Hiding the hardware was only half the job; the other half was making a mistake harmless. Every joint of the arm has a minimum and maximum angle, and every move command passes through constrain() before it reaches the servo. Ask the big arm for 40 degrees and it stops at 80, the lowest angle its limits allow — so a student could try any number they liked, and the worst outcome was a movement that did less than they asked.
// --- DO NOT TOUCH THIS PART ---
class KeyestudioArm {
private:
Servo base, bigArm, smallArm, claw;
// Safety Limits
int limitMin[4] = {0, 80, 30, 85};
int limitMax[4] = {180, 180, 150, 150};
int currentPos[4] = {90, 90, 90, 110}; // Initial Startup Positions
public:
void setup() {
base.attach(16);
bigArm.attach(17);
smallArm.attach(2);
claw.attach(4);
// Move to initial position slowly
moveBase(90); moveBig(90); moveSmall(90); moveClaw(110);
}
void moveBase(int angle) {
int safe = constrain(angle, limitMin[0], limitMax[0]);
base.write(safe);
}
