Ghost Polaroid

1 Comment



  1. Connection from the camera to Arduino

The main idea of our concept is presented in the following: when a picture is taken, it would be found in computer immediately by USB connection and modified with an image manipulation program, then be printed with a small photo printer.




But there was a problem with our cheap toy digital camera: when we connected the camera to our computer with a USB cable, the camera went automatically to a “USB mode” and couldn’t let us take pictures at the same time. To solve this problem we decided to hack the USB wire and camera shutter and develop an Arduino program, which makes the camera more intelligent: when we push the camera shutter, it goes to USB mode in 5 seconds and exits the camera USB mode after 20 seconds (the approximate time for our photo manipulation and printing) so we can take the next picture.

There are four wires inside a USB cord which are colored red, black, white and green. Red, as standard color for positive wires, has 5 volts. Black is the ground wire as for negative or ground connections. The other two are translation data wires. We cut the red wire away: one port, which connected to the computer, is use for the power support of our electronic circuit. The other port, which connected to the camera, would be linked to a PNP transistor. With an Arduino program, the camera shutter should be seen as an input to control whether the USB circuit is connected or switched off. The electronic circuit is seen in the picture below.





  1. Image manipulation


Photos were manipulated in two different ways:

  1. Add a scary creature into the background space of the photo, e.g. a ghost, zombie.
  2. Or have the faces covered with random scary face masks. But in the end we added some meme face images (grumpy cat, doge, rage faces) to make the output even more surprising.



We wrote a java program that serves three main functions:

  1. Runs a thread which checks if the camera USB storage is connected. If yes, it fetches the latest image to the local folder. Due to the Arduino program’s setting, we have 15 seconds to copy the latest image which is usually more than enough.
  2. Analyzes the image content. We used the OpenCV library to detect face position and size. If there is enough space between the faces, the image manipulation program will choose manipulation type 1, otherwise type 2.
  3. Gives a print command to the photo printer via Java Print API.


  1. Print


At the beginning of the project we were quite unsure which printer would be the most convenient one to use and we didn’t have much time to decide. First we were thinking of the small thermal printer used at the cash points, but since the thermal printer can only print receipts, we found it really weird to have a “Polaroid” which prints black-white receipts. Luckily, we found a Canon mini photo printer on Amazon which was delivered on the next day. The mini photo printer can even work as a wireless device which makes it much easier to design the Polaroid prototype.

Java offers an API for accessing the print jobs and settings. First we encountered some troubles with the page layout, but we managed to hack the settings in the hash table. We were very happy as the photos were successfully printed via Java print API command.



  1. Decoration 


The prototype is a wooden case with the toy camera and the mini printer inside. We used 9mm MDF for building the case. To maintain stability, the boards were cut to puzzle-like shapes so that it can be easily patched together. The back side of the case was left open for cables and wires. In the end we sprayed the boards with varnish to create the glossy coat of a Polaroid.


We cut a big round hole on the front side and put a round glass plate of the same size into the big hole to make it looks like an old fashioned lens opening. There is a smaller hole on the upper board so that one can click the shutter release through the hole. The case edges are additionally protected by metal foils.

The logo and mascot ghost were also engraved by the laser cutter. Actually, the manipulated photos were supposed to be scary, however a meme Polaroid was built instead 😉 Well, that is why the ghost looks so cute.


Grantiger Alois

Leave a comment

By Markus Fußenegger & Korbinian Königseder


Looping Louie

Original Looping Louie Game

We developed a concept to modify the famous children’s game Looping Louie. It is a simple reaction game for 4 players where a plane, controlled by a guy named Louie (German: Alois) tries to hit the player’s chickens. The players have to vault the plane with a catapult over their chickens, represented as tokens. Every player owns three chickens. The game ends if only one player has tokens left.

Grantiger Alois

Final Grantiger Alois

Because this concept gets boring pretty quick, we wanted to modify it. Therefore we created some concepts which enhance the game experience for every player. This should be done with the help of an Iteaduino controller board. The main idea was to control the plane by an enhanced AI which sensors the game’s environmental properties. This AI basically should be very cruel, for example it should attack certain players chickens without them having a chance to react or defend against. But other players should be ignored by Louie. This game mechanism would create a completely new game experience never seen before.

To reach this goal we had to design several different components which have to be added to the game. These main components of the concept are seen in the picture below:

Main Concept

Main Concept

1. Dynamic motor control:
We chose to use the built-in motor, because of its specific size and gearbox and implement the dynamic motor control by adding a  external motor control board. We attached the external motor control to ensure that we are able to do reverse and forward motion and are allowed to set the speed of Louie.

2. Flexible height control:
Allowsto let the plane jump and float. But it should not interfere with the natural dynamics of the plane.
The first concept to control the height level was with an electromagnet built in the crane, and a static magnet in the counter weight of the plane. This concept wasn’t feasible because we couldn’t find an electronic magnet which was strong enough to pull the plane up and to fit in unison inside the crane. After this setback we decided to build a cable control to pull up the plane by a stepper motor.

3. Height sensor:
We planned to measure the height of the plane with a potentiometer attached to the hinge of the crane. Based on the angle of the plane we can meter different resistant values. Then these are converted into degrees by software.

4. Position tracking:
As Louie moves around the board the base of the crane closes several contacts on the ground. With this measures we are able to calculate Louie’s position by interpolation based on his velocity.

5. Light barrier to observe the token’s movements:
Every time a token falls it brakes a light barrier that indicates a lost chicken.

6. Sensor the catapult’s state
If the player pushes down the catapult a simple contact gets closed by a conductive metal on the bottom of the catapult.

7. Serial Communication with an AI provider
Because the AI could get very complex we thought to do the AI processing on an external computer. So we can use the power of the Iteaduino board to collect sensor data and execute commands provided by the external PC software.

Iteaduino Pin Configuration

Iteaduino Pin Configuration


First we built the light barriers as it seemed that they are the easiest additional module. We placed a LED under the ramp chicken ramp and a photoconductive cell on the top of the ramp. First tests were very promising and coin loses could be measured very precisely. As we started to work at the side arm, we continued to finish that component. So we went on and included two contacts onto the ground under the catapult. So that every time a player hits the catapult, those two contacts get closed by a thin cooper layer. This didn’t work perfectly, because of a small scope in the suspension of the catapult. But after curving the cooper layer the contacts worked almost every hit.

Light Barrier and Catapult Contact

Light Barrier and Catapult Contact

The next step was to include sliding contacts between the crane and the platform. We again used a thin cooper layer and a piece of conductive metal. These connections were responsible to bring the supply voltage and a control wire to the planned height sensor on top of the crane. The third connector tracks the position of the plane. Concurrent we hacked a potentiometer, to sensor the height of the plane. It was placed between the crane and the crane jib. First tests, where we measured the resistant of the potentiometer, just worked correctly. Some modifications and grindings on the crane need to be done, but finally there was no bigger trouble. Additionally we added four contacts on the top of the base to measure the current position of Louie. The idea was to register if one of the contact was closed and then interpolate the current position of Louie.

Sliding Contacts

Sliding Contacts

Meanwhile we ordered a motor control board for the built-in motor and a stepper motor for the height control. We were planning to hook up the motor with our motor control, to get full control over the built-in motor. This allowed us to control Louie’s speed and direction. This also worked very well, but the troubles began as we mounted or stepper motor. It was connected over a wire to the counterweight of Louie. Unluckily the stepper motor was way too weak to sling Louie up in the air. So we stated that lifting Louie would be fully sufficient.

Louie Assembly

Louie Assembly

Followed up we assembled all parts and tested every component. Again we run into some major problems. We weren’t able to get any valid data from our height sensor. After we inspected our wiring we found out that we forgot the ground signal line to our potentiometer. Normally this would not have been a big problem, but to get another signal line up in our crane we had do add another sliding contact. We solved it by inserting the new cable into Louie’s shaft. After some small hassle it worked very well, even in motion.

Finally we began to test everything together, and this was the point our whole concept started to collapse. Our height measure could not transmit its data because the sliding contacts were losing contact when Louie was vaulted into the air. Also the position contacts could not be registered every time the plane past one. Besides that our cable to lift Louie would drill itself up in less than five turns and got stuck in the crane shaft, nearly unable to remove. After these big letdowns we decided to rethink our concept and simplify it a bit. We wanted to remove the stepper motor and the cable system and attach them to a catapult. The catapult should be controlled by an AI which should act like a good human player. But this worked not even as close as expected and we thrashed this idea shortly after.



After all of these problems we ran into one we didn’t even thought of it could happen. The Iteaduino Lite we used offers only 8kb of flash memory and almost 2kb are already used for the bootloader. We reached this kb limit in no time with more features left to code. We had to remove the complete serial communication to save crucial flash memory space and had to implement the AI on our Iteaduino board.

To make it to the presentation we wanted to simplify the concept even more, removed the height sensor and imprecise position contacts. Based on the modules we had left, we developed a simple AI which controls our Louie making it nearly impossible for the player to defend its chicken against Louie and the catapult contacts allowing the user to interact with the game logic.

Night Gaming

Night Gaming

Final Result:

In the end Grantiger Alois was short on some features, but the end result is promising for only one week of sketching and implementation. After the game is set up, the main player has to initiate the game. He presses his catapult down for about two seconds. The green LED mounted on the middle base is indicating if the game was started successfully. After that Louie goes into start mode, whereas he accelerates to reach his maximum speed. When reached he switches into random mode. Now Louie is nearly unpredictable because he changes his speed, direction and even stops for some time. The players need to concentrate hard to follow his exact movements and react quickly to movement changes, to save all tokens. If a token gets hit, Louie enters into his furious mode, whereas he accelerates to maximum speed. If only one player is left Louie stops and the game ends. To see Louie in movement watch the video below:


Leave a comment

Idea & Concept

We decided to hack the good old wooden labyrinth. We had the idea to play it with potentiometers and by a controller which imitates the board and let it act like this with a position sensor. Therefore we thought about making the game harder by inverting the x and y-axis when passing a certain stage in the game. Other features should be a colourful led strip inside which reacts on different switches and game phases and magnets should influence the ball.


After we programmed the Arduino clone (iteaduino) that the potentiometers and the position sensor were able to control the servos, the next thing was to find a way to move the axes inside the game by the servos.

The challenge was that no one should be able see the changes from outside. So we tried it with two thick gums that we fixed to the lever of the servos and twisted the gums two times around the sticks. We realized that the sticks are too slippery for the gums, so we used tape to get rid of that. Then we attached the servos to the case by two screws instead of glue to have a stable construction because the gums have to be under tension to work fine. The potentiometers were also fixed to the case with a nut.

The next step was to calibrate the servos with the potentiometers that they are horizontal at the start and the mapping to the potentiometers is intuitive. This was a real problem in our project because the calibration of the servos was mostly lost after playing a while (natural problem of the gums), so we programmed an extra calibration program. We realized then that it’s hard to play the game with the thin potentiometers, so we purchased knobs for the potentiometers.

After this we build a controller for the position sensor. For the controller itself we made a template (looking like playstation controllers) and let it cut by the LMU laser cutter. We needed five different wires, so we chose the usb cable of an old keyboard for the connection. We added also a switch outside of the case to switch between potentiometer and position sensor control.

Our next challenge was to attach the rgb led strip to the case and find appropriate transistors for the led strips that we don’t destroy our rgb leds or our iteaduino. It had to be an N-Channel MOSFET with appropriate characteristics to match the power consumption of the LED strip. We settled for the IRF520N which can provide more than enough power.


Additionally we attached an electromagnet in one hole of the game to lock the second ball behind a barrier. This ball is released when you push a button with your ball in another hole before the barrier. This was also done with the same MOSFET we used for the LED strip.


The next thing was to find a way how we can implement switches for the ball. Our first idea: Attaching the switch to the underneath the board and exposing it by drilling a tiny hole and sticking parts of a cable through it that should trigger the switch. This idea did work fine, but influenced the path of the ball. Furthermore because of the width of the lanes we would have needed to use at least two switches to cover the whole width. We tried other approaches using copper tape that we arranged on the board in several ways. In the end we glued two little tapes leaving a small cut across the lane that is bridged when the ball rolls over it and connect them with to cables, resulting in a switch. So we added four switches to the game:

  • 1st switch: startfield –> leds are turned on
  • 2nd switch: release the second ball
  • 3rd switch: inverted x and y axis
  • 4th switch: finish –> fading rgb light show

At last we took an arduino prototype board (that you can directly attached to the iteaduino) to solder our wiring on it, because the pins in the breadboard were not stable and it needs too much place in the case. This work was a pain because the layout of the prototyping board was not very intuitive. Additionally we didn’t test the transistors we used beforehand, so at first we thought something went wrong when soldering. But instead the transistors were broken, so we had to solder them out and replace them with new ones. It got to the point that we needed to replace one transistor with another model. This model wasn’t able to drive the electromagnet so we swapped the PINs for the electromagnet and the green color of the LED strip, resulting in green going binary (on/off).

The most persistent problem we had until minutes before the presentation was the random twitching of our servos. We still don’t know where exactly it came from and it appeared and disappeared randomly within the hour. Sometimes we could fix it (i.e. by adding a delay to the loop that controlled the servos), but in the end it always reappeared after a while. We noticed that the power LED of the iteaduino was always flickering when the servos twitched, so we figured it might be a power problem. Minutes before the presentation we fixed it by replacing the iteaduino with an Arduino Uno. Phew.

And for the finish, a video that shows the development from the beginning to the end:

Next Steps

The next steps for Madlab could include:

  • More steering modes: e.g. drunk mode (overshooting) or vibration mode
  • Better handling of mode switches
  • Moving walls
  • Using electro magnets to accelerate/decelerate the ball
  • Highscores for speed


Leave a comment

Idea and Concept
Our initial idea was to buy a toy train and modify its wagons by adding two compressing springs with a set and release mechanism. Positioned on each spring would have been a coloured ball that would jump out of the wagon when the mechanism was released.

The reset of the system would have had to be manual and only two balls per time and wagon could have been made jump each time the apparatus was released. We also intended a second surprise mechanism that made it hard to connect the wagons in the first place and to make it somehow difficult to put the balls onto the wagon so it would have been all the more frustrating when the balls flew off. Also the wagons would have automatically separated after a certain time.

What became of the concept you can see here in the video of the final result:


Getting to work and solving the unsolvable

The concept was then split into two Major assignments:

First: Finding a toy-train in the appropriate size with enough space for our modifications and
Second: Finding springs with the required properties (not too hard to draw back (tensile force) but with a good enough take off power) and designing an apparatus that made balls jump with them.

What we did not know at that point: With our final solution of the second assignment came a third major assignment we did not know of while scheduling our time.

After wasting two costly days on solving both major assignments the planned way we decided to solve it by adding work to reduce it:

Instead of buying a toy-train (and wasting precious time looking for it) we decided to built it ourselves as a made-to-measure solution. Using the leftover-stock we took some wood and learned to use Adobe Illustrator for the vector design.

The base for all the measurements was the remote controlled toy-car we had found in the workshop on a coincidence. We designated the chassis to be our towing vehicle. Later followed the self-made chassis and wheels for the wagons. (We could not find any to buy in the required dimensions)

Lesson learned: I am convinced that despite the additional work we put in making it up from zero we did save a lot of time and learned a lot in the process as well. (Using the lasercutter, working with Adobe Illustrator,how to use the tools in the workshop, AND: improvise, improvise, improvise)


The second major assignment turned to the most unexpected result. After focusing days on first finding the perfect spring (which turned out to be a disaster) and make it work SOMEHOW. The solution lay somewhere totally different. A frustration-solving stroll through the workshop brought me to a discarded piece of acrylic glass. It was both: surprisingly flexible and yet dimensionally stable. And immediately a totally new idea took shape. The prototype on the new concept took only a few minutes and worked on the first run. Here a demonstration:

The new concept brought several more advantages: We no longer had to reset the system for every new round. a hacked 360° servo  could keep the springless construction running infinitely. That also meant we were no longer limited to a 1:1 ratio on balls and springs: we now could shoot around a whole load of balls in every wagon.

Lesson learned: Stop trying to reinvent the car when all  need is a wheel.

With the train and the spring-less construction done the day before the presentation, we thought nothing could go wrong now. We thought the electronics would be easy. A mistake that literally cost us our sleep the last night.

Taking up an idea we had had quite in the beginning we used popsicle-sticks with a copper coating to transfer signals plus energy and keep the train able to make turns because the coupling was flexible. It was a rather simple but effective solution. Still it turned out to be very very time consuming and starting a task that requires a focused mind and a still hand after 12 hours of work is not the best idea. Yet we managed it and after 6 more hours everything was working just fine.

The Arduino gets its power from a 9V battery on the first train. From the Arduino emerge 5 cables: A Voltage cable with 5V and a Ground cable that serially connect to every servo. Three seperate Signal cables, so every servo can be controlled autonomosly.

Lesson learned: Do not sleep in the CIP-Pool. You risk freezing to death while asleep. Seriously.
Things that were left out – Ideas for the future

The whole “Trains falling apart just before the balls start jumping out”. We threw the idea aboard after realizing it would require one arduino and a battery per wagon. Plus a strong repellant like an electric stud or electromagnets. Two things that are highly energy consuming. And by adding those the space for the eggs would have been considerably minimzied.

Springs. As mentioned above it didn’t work out. Not only the mechanism was catastrophic, but also aquiring fitting springs… It seems that springs are usually only produced for companies that use them for their tools. The springs we found were all too big or had too much tensile force. Thinking around the corned helped here. A stroll through the lab and we really simply ran into the solution.

Buying a toy train. Looking for something extremly specific (exact measurments, size, material) is really hard. If you have any talent in “do it yourself” then do just that. No point in fearing failure. Just do it. At the very least you will learn a lesson.

Acoustics: At one point we intended the train to make some funny childisch train sounds, time killed the idea rather soon, but we still liked it

Light effects: Blue subfloor illumination. Again time was the killer but this would be the simplest of all to add as we have already designed the wagons with extra space for an additional battery and space left for some LEDs.

A stronger towing vehicle: Altough we tested the admissable total weight of the toy car to be 1,5 kg it still had trouble towing the wagons. Either the last wagon has to go, or the towing vehicle needs a stronger engine.

A remote controlled starter: We still have to start the arduino manually. Adding a remote would certainly improve the effect.


Things that were added

Easter Eggs instead of balls (spontanously)

Selfmade train + wheels

10 Eggs rather than two balls. The more eggs the more the fun


Final words by the author

Despite the batch of chaos in the final 24 hours I really really enjoyed the course. The project with all its ups and downs was really cool, the learning curve amazing and the people were not only helpful but especially the lunchtimes were real fun. For every stressful moment (including having to sleep on the CIP-Pool floor): it was worth it.

Hardware Hacks: Servo Hacking

Leave a comment

For some reason many people – even computer science students – are originally afraid of unscrewing and opening electrical devices. While it is truly not recommendable while said device is currently under charge I believe it provides a lot of general understanding on how a device works and also enhances the learning process. Things get less abstract when we understand HOW. It makes us think of the WHY and why not to make it better. So put your fears aside and just start to unscrew something. Something not too expensive so you don’t have to worry about messing up too much. Something that will be useful if you unscrew and modify it for example. A Servo for example.

A Servo is some little device that can turn something around, but only to and from a certain angle (ca. 90°). But if you want a Merry-Go-Round you will have to get rid of the block. So they work like this:


Here is how to:

First off: There are several versions of servos. Each one more difficult to hack:

  • 100% plastic servos – the easiest to hack
  • Plastic servos with a metal potentiometer – hackable with a small workaround
  • Metal servos: The whole gear-work plus potentiometer are made of metal – if you cannot work an angle grinder, forget it.

I’m going to describe how to hack the first and second one as they are the ones we usually use at Sketching with Hardware.

So let’s get started.

First a little overview of the innards of a servo:

A look inside a servo

If you hack a servo there are basically two things you have to do:

  1. Remove the stopper so the gears can turn 360°. This is usually positioned on the drive gear with the output spline.
  2. Modify the potentiometer – output spline connection so that the potentiometer is fixated but the output spline can still turn.

So now we can start: unscrew the servo. But keep the side with the output spline up. Otherwise the gears may fall out! Don’t worry about the motor and control circuit falling out on the other side. They are fastened really well.

After opening the servo you’ll find an armada of gearwheels. I truly recommend you now make a photo from at least two angles (up and side) so you know how to put it back together – as there are small variations on the gearwheel allocation between the different models. Now look closely at the gearwheels (you have to take them out) one has a plastic plug over some gearwheels. This is the stopper. Use a cutting pliers to remove it.

In some cases there are no gearwheels where the stopper has been. If you are very sure in its use use the bandsaw to add them manually otherwise ask somebody who does or look for a servo that does not require this step!

With the gearwheels now capable of turning 360° we can move to the next step: The potentiometer

Now first a little explanation about how the motor and potentiometer work together: The motor is able to go around infinitely, but is stopped by the potentiometer that can only go 90°. They are connected by gearwheels. The motor drives the gears who are controlled by the potentiometer. The potentiometer can only turn on a 90° radius. On the potentiometer the output spline is mounted. That in turn is the key to turning the servo arms.

What we know now: the motor does not turn the output spline directly, but connects to the gears that do. Unfortunately those gears are connected to the potentiometer with a pin. But we do not want the potentiometer to influence our movements.

The solution is rather easy: you have to drill a hole in the output spline where the potentiometer pin goes in. You basically just drill out the thread (dt. Gewinde). I recommend using a steel drill and it will go through like butter. Also take care not to screw the vice too tight or you damage the gears. Putting some cardboard between the vice and gear helps.

Finally: Fixating the potentiometer

The potentiometer turned to one side gives full power. Turned completely to the other side it turns the power off. Best thing would be to keep it in the middle (or at highest if you require it) to test the current setting you can use an LCR-meter.

You now have to fixate the position of the potentiometer. Otherwise you risk that it moves to the “power-off” state sometime later. For that last step you can try to somehow glue it. With the plastic versions I was very successful using the hot glue gun. Although you risk getting a few minor burns on your fingers while molding it. After applying the hot glue let it cool down. Then cut the protruding hot glue away with a Stanley knife (horizontally, or you draw the glue back out). For the metal  potentiometer the hot glue does not work really well, but I did not have the time for further materials science. If you find something better that hot glue for those, please share and post your results in the comments.

And that’s it. Congratulations! You just hacked a servo.


Leave a comment


Our brainstorming was very intensive. We examined various factors, especially the items “Good” vs. “Evil”. We associated night, fear and attack with “Evil”. Why we chose a teddy bear is very easy to describe. During our whole brainstorming we always recollected to the teddy bear. It never turns out of our minds. It is the typical toy of everyone’s childhood. Everybody has a relationship to his teddy. It is a typical companion, so we decided to apply our teddy associations as the “Good” aspect for the project.

We thought about situations where we would like to have a special friend with us. Sometimes when it is very late and you have to go home alone you feel very uncomfortable. An attender would be perfect in such a situation.  In the case an attacker follows you or attacks you, your friend the teddy bear includes some rescue levels. Possible features would be an included pepperspray, barking sound, police sound, blue light effects or an emergency call to the police.





Our concept is a teddy bear, not too big, which fits in every handbag to carry it with you. We decided to integrate three rescue levels depending on the degree of danger. When you are going home alone in the night and you feel uncomfortable or you are imagining that someone is following you, the first level of the Rescute can be activated. Immediately the bear starts to bark. Thus, the follower will notice you are not alone, he will think you have a dog with you, not knowing that there is far more in your bag. Perhaps the follower is already warned and goes away. If not, you can select the second level. The bear starts to shake his head and its eyes begin to flash in blue. Additionally, there comes police sound out of its body. The bear simulates the police arriving. If this is not discouraging the attacker or he starts attacking you you can select the third and last level of Rescute, the Pepper spray with light effects. This will help you to target perfectly at the aggressors eyes. The third level will give you enough time to run away or to get help.



How does it work?

First of all, we thought about the connective of our bear, the basis of our levels. Therefore, we remembered of the toys which have an integrated music box, controllable by a trigger line. We want to use this principle for our project. We used a pipe with copper tape. For each level we put two piece of copper tape inside the pipe which are separated from each other. These tapes will be connected by steel wool which connects the two copper tape sides. The wool hangs on a line. This line could be applied by lift pass holder which is fixed on the inner bottom of the bear. It closes the circuit and the effects will be triggered. When someone pulls the line the wool connects two of the tapes and releases the connective effect.



For the sound effects we used a greeting card sound modul. We tried to build an audio amplifier to multiply the sound but this was not easy. So we put a pipe above the original loud speaker. This improved the volume of the sound with a great difference.



For the blue eyes we bought white lamps and painted them blue. The shaking head is a servo which is fixed between the shoulders of the bear. The moving part is fixed with plexiglass and hot glue at the head.



The pepperspray is integrated by a hacked airwick. This airwick starts to spray by getting an electric impulse via piezo ignition. We controlled this impulse by one pin of the arduino. For the audience at the presentation we did not use a pepperspray but a airwick spray.

For the light effect of the spray we used three red lamps and three white lamps connected by a transistor with two parallel circuits, one for white light, one for red light. For those lights the arduino energy was not enough. Thus, we used a 9 V power plug.





Pins already contain electrical charge:

To connect our pipe circuit to the arduino, we wanted to read the digital pin. While we uploaded the signal via serial, we discovered that the pins already contained a electrical charge although the circuit was not yet closed. To circumvent this problem we attached groundings by resistors. These connect the pins with ground. So the right signal was read by serial.

Find a right transistor:

For the light effect of the pepperspray we needed a transistor circuit. The circuit was easy to build but to find the right transistor not. Transistors and voltage regulators look very similar, so our first trials failed because we used no transistor. After we found the “real” transistor we had to decide which transistor type we need. Which number is for which voltage and which type (npn, pnp) is appropriate for our circuit. So for the usage of transistors, you have to read a lot of data sheets and documentations about transistors. As the right transistor was found, we discovered that all transistors differ in their allocation of emitter, collector and base. So we had to read more data sheets and we learned to like them.


The next problem is also concerned with the light effect of the pepperspray: Our led chain did not react on input from the Arduino pin. The leds were glowing all the time, also without power of the arduino. Different voltages caused this problem. 5 V of the Arduino USB port are not similar to the 5 V of the power supply. This could be corrected by equipotential.  Now the Arduino has only one power source: power plug, which is directly connected to arduino.


Experiment to construct an amplifier:

The greeting card sound modules were very quite. So we wanted to construct a amplifier. We found a simple circuit diagram and started to construct.


Because we did not have the named transistor, we used another. Indeed, the bigger speaker was able to make some noise, unfortunately not our recorded barking and siren sound. Because time was precious, we decided to take the physical way. A pipe should amplify the volume. This worked great.


Sound module:

In spite of correct circuite and correct code we had problems to activate the sound modules with the arduino pins. We checked all contacts with the multimeter and could not find any leak.

Our problem was that we used only one speaker for two music modules. So the 5 V power of the arduino was divided in two parts. The power from source went back over the ground connection from the other sound module without activating the speaker. So each module had only 2.5 V, insufficient power to play back sounds.

The problem could be resolved by usage of a second speaker.

Steel wool in pipe circulation:

The steel wool on the line damaged several times the copper tape and the solder joint. So we lost the contact to the Arduino pin and the whole prototype did not work anymore. We had to exchange the circuit several times.

For presentation we wrapped the steel wool loosely with more copper tape, so that is more softer than the steel wool but as flexible. This is no perfect solution, but we could present our prototype without problems.

Next steps

If we would have had more time to strengthen Rescute, we would like to test more variants for the pipe circuit instead of the steel wool. Perhaps something more smooth with less attrition.

Moreover we would like to use a better sound module with amplifier for the barking and siren sound. So that it sounds more realistic.

If our implementation of our concept is perfect without failures, we would beef up the concept with a fourth rescue level. While the fourth level is triggered, Rescute shall send automatically an emergency call. Maybe this could be implemented by a bluetooth connection to the smartphone, which afterwards dials automatically the 112.

Unfortunately the week is over and we have no time left to extend Rescute.


Day 7 – Preparing for the final presentation

Leave a comment

The last day of Sketching with Hardware is known to be the most hectic one, mainly because the projects have to be presented to interested visitors at twelve o’clock. Therefore each group was focused to finalize their project. Some groups were able to refine their program code, others were hectically soldering and drilling. The following “Panic-O-Meter” chart illustrates each group’s mental state over the morning.


Panic level on day seven

Panic level on day seven


Group 1:
The “Rescute“ team members finished their project already on day six and were quite relaxed on day seven. With their project finished and ready for the presentation they spent the morning capturing good sound samples and preparing their final presentation. After the presentation their panic level raised a bit. But in this case it was not project related, they had to write an important test afterwards.


Group 2:
After a hard night of working group two was focused to get their project done. They spent the whole night soldering in the universities computer lab and even slept there. Luckily they were able to finish their electronics and could concentrate on building the last train components. As they haven’t slept a lot group “Osterexpress” started with a very high stress level into the day, but as their project made good progress their panic level decremented significantly over the morning. Minutes before the presentation their project was finished and ready for the public demonstration.




Group 3:
Team “Togebear“ had to fight against some small faults, due to a bad contact inside their bear. They spent quite some time finding the exact problem, but as they found it they were able to solve it pretty quickly. The rest of the morning they focused on code optimization and cleanup. After the teddy bear passed the final functionality tests they were ready and good to go for the presentation.


Group 4:
After a hectic Tuesday team “Looping Louie” finally got their game running. The morning before the presentation should be spent for optimization and optic fixes, but it came worse. As the team played some test matches “Louie” had some blackouts and they got worse from minute to minute, until “Louie” completely denied to work. Hectically (panic level ten and higher) the team tried to resolve the problem, but could not allocate it before the presentation. Shortly after the presentation the problem was identified as a soldering error on the motor control board, which led to a complete burnout of the motor control unit.


Group 5:
Team “Madlab” detected some servomotor calibration problems in the morning. They were quite stressed as they were not sure if they could solve it until the presentation starts. Luckily they were able to find the correct motor calibration and enjoyed some test games. Servomotor control, LEDs and magnets were working properly, therefore their panic level went from “total freak-out” to “absolutely chilled”




Group 6:
The day started good for team “Ghostcamera” because their project was already working on Tuesday evening. They did some final configuration tasks and tried a lot of different test cases to ensure that the camera setup will be working properly when the public presentation starts. Because they did not run in any major problems denying a good presentation their panic level was dead low the whole morning.


At twelve o’ clock most teams were ready, others not, but the public presentation started anyway.


Older Entries