Category Archives: arduino

Arduino Tamagotchi, first power up!

That was more intense and exciting than I anticipated! I thought building my first “homebrew Arduino”  from an atmega 328p and controlling an OLED via I2C shouldn’t be too complicated.

In fact, it isn’t, but there are a couple of things you have to think of, especially when you do it in this contrained space.

20161204_173740sAnd actually, you can see the wiring mistake I did up there, I connected the RST of the chip and the DTR of the FTDI port wrong. But chip, FTDI and capacitor survived it…

I also did the buttons wrong as the buttons were rotated and always ON / HIGH. So, I changed the layout from this:20161204_183737s

To this:20161211_212541So now the power is on the upper part of the buttons, instead of the right (for the left buttons).

Yeah, so finally, here’s the first power up! The date / time is wrong because the third perf board with the RTC and the speaker are not connected yet, so the clock starts when the atmega is powering up:

 

 

Arduino Tamagotchi from the left

Arduino Tamagotchi – first board fitting (Pt 2a of 3)

The design principle of keeping everything to a minimum is also paramount in the Tamagotchi project. In this case, I wanted to use the Arduino chip itself and layout a board around it by myself and luckily, I also found out that my slaughtered external phone battery delivered 5.1 Volts which is in the operating range of the Arudino.

Tamagotchi PCBs

Tamagotchi PCBs

Top left, you see the front board with the display and the intended buttons (only one placed), top middle the board for the Arduino and it socket plus an USB port that will be used for the LiPo charger board (the one that is close to the battery) and on the right it’s the back plate containing the speaker and the RTC board. Continue reading

breadboard tamagotchi

palmsize Tamagotchi

Recently, I’ve come across a really nice Tamagotchi project on Instructables.

Tamagotchies are virtual pets in little devices (later on also apps, etc) that the user has to feed, clean up after and play with. They are a nice addition in my thinking on social robotics. Also while still collecting knowledge for the 68k computer, I learned that I want to start with a stripped down Arduino, not a Nano I usually work with. So this is an ideal little weekend project to learn a few things. Continue reading

first “unit test” in programming an arduino mini pro

so, after i’ve connected the head and its servos to trashbot 6, it’s now time to work on the actual control of the neck servos. unfortunately, the servo-board connected to the raspberry is not sufficient to control the neck servos since the body is already using 15 servos and the controller only has space for 16.

so i thought to use an arduino mini pro for this since it has 6 PWM outputs that can control six servos (people have noted that the output pin doesn’t necessarily have to be capable of PWM to control a servo). Continue reading

trashbot 6, quick video walk through

most of this work has been done over christmas, but only now i found the time to at least do a quick tour around the bot. here are some highlights:

  • arduino nano changed to raspberry pi 2 & wifi
  • moved controller from back to hips
  • added 16 channel i2c servo controller
  • new foot construction adding an additional degree of freedom (DoF)
  • reconstructed legs that are lighter and now take up new batteries
  • power distribution board including i2c current / voltage measurement
  • accelerometer and gyro sensor (i2c) moved to “belly” instead of neck
  • added arms with shoulders (two DoF)
  • changed spine, reduced complexity
  • removed head for now (being redesigned)

Trashbot 5, new hips, first movements

Last week I added three degrees more to Trashbot, two hip servos for forward movement (“kicking”) and one to the bone.

This week I found some time to do the first single servo movements and tests to check out the new geometry of the bot since the broader hips will affect the Center of Gravity etc. Here’s the first attempt to do what the normal gait would do: shift the body to one foot:

So, definetly software teaching me how to improve hardware… Next draft iteration: Continue reading

Working on more Degrees of Freedom in the legs of Trashbot

I’ve been working on Trashbot for quite a while now, but the basic gait mechanism is still the same as in version one. The hips’ movements and the distance between the legs define the possible step length. This is annoying since the robot is rather tall and you’d expect that he’ll walk a bit faster than he actually does. However, moving faster induces stronger vibrations in the skeleton and makes him fall much easier.

trashbot 4 in full length

Also, the upper part of the body will tilt “stronger” when Continue reading

trashbot 4 fully assembled

trashbot 4 and more

this time it took really long to make more progress on trashbot but i had the feeling that there were many little improvements that made the bot better and somehow it felt like none of them were big enough to be worth a post.

now in the end i learn that quite a lot happened during the last 8 or so weeks and over easter i invested some time also into the cleanup of the software.

first of all, i added shins to the legs so that he wouldn’t swing too much when shifting his weight from one foot to the other. i used some screw / hooks that you use to hang wired lamps and have a tension on the wires:

IMAG0948r

next i couldn’t resist to Continue reading

using a laser to investigate trashbot 3’s walking pattern & balancing effects

recently, i had the idea to attach a laser pointer to trashbot’s neck and investigate the amplitudes of the laser on the ceiling. this time, the blog entry is shorter but the “how-to” is in the video:

from the results you can see much better the difference between active balancing:

laser active balance

vs no balancing (the spine is stiff, the upper body moves with the hip, thus larger amplitudes):

active spine off laser

with this technique, i hope to be able to document further improvements on the movement, especially when i connect the gait pattern with the balancing mechanisms as scientific robots do.

i recently contrasted trashbot 3’s walk with the spine balancing or bein static and was not happy with the result of the video. one can have the impression that active vs non-active balancing is somewhat similar but in fact the real robot “feels” different as we’ve seen in the video above.

next, i’ll attach a little camera (gopro clone) to the trashbot’s chest to view the gait from “first person” perspective…

 

 

trashbot 3: a gimbal-like autonomous 2DOF spine

(if you can’t wait to see the end result, scroll down to the bottom watch the second last video ;-) )

after the lower body was walking and free from seizures when starting up the arduino, it was time to think about the rest of the robot. certainly, there’s still much to improve on the gait and most importantly the feet, but it’s my goal to build up the complete robot first before iterating the parts (the feet are under constant change as the weight distribution varies and also i’m constantly learning how to improve gait pattern.)

in contrast to many commercially available robots (like the bioloid or the lynxmotion pete), i wanted to have a machine that feels more natural and can move a bit more freely, especially with the head and the body trunk. usually, these two are rather stiff or absent (head). people invest dozens of servos into legs but not a single one into the spine. for me, the two servo legs are “good enough” for the moment, i’ll invest in the rest first.

on the other hand i’ve seen many gimbal mechanics mostly for quadcopters carrying the camera. some of them were even arduino controlled and here and there, you can see some code. interestingly, i wasn’t really able to find servo-driven automatic gimbals, most of those are driven by dc motors.

let’s view the goal first:

okay, here’s how i built it:

the base was taken from anold bike light:

bike light

and i added the first servo that can swing from left to right:

lower servo for the back

next up, was the second servo driving the chest allowing the bot to lean forward. it seemed to me that these are the two directions the biped needs to be stabilised in, since the feed generate a tilt to the sides and the hips rotate body on that tilted axis.

i wanted to have a possibility to update the mechanism easily and didn’t want to glue or solder anything, also bulky servo brackets seemed not the right way to go aesthetically. so i came up with a wire-based connection of the two made from a recycled wire that i had left from hanging lamps and some power connectors and a spring from the recycled typewriter:

connecting chest and back servo

it took a while to find the right parts from the type writer and re-arrange them so that i had a broad enough shoulder that could work as a “servo bracket” while being stable enough to support more hardware on top later on.  and i recycled my first two letters “M” and “N”:

chest and should bracket

finally, connecting the two parts to this:

upper body assembled

it was really tricky to find some parts to surround the upper servo so that i could atttach a second ankle on the other side of the servo. kind of proud to have it included in the wire fixation structure… also, you see a recycled air pump holder from an old bike that protects the bot’s chest servo should it fall backwards.

next i recycled a heat pipe from an old (TV?) pcb: heat pipe

and shaped it to support the upper body on top of the hips and TADAA! here’s the assembled trashbot 3: trashbot v3 mechanics front

trashbot v3 assembled mechanics side

now it was time to develop the electronics and the software. (actually, i developed the software with the spine detached and assembled the whole beast when the autonomous gimbal was actually working).

standard setup with the gyro / accel MPU6050, most importantly with the interrupt attached to the arduino:

MPU6050

 

i tried a could of libraries for getting decent values (including the kalman filtering that can be done on the DSP of the MPU itself), but jeff rowberg’s is simply the best.

finally i wrote my own PID functions, mostly to understand how the maths work and how and whether i can fine tune something. PIDs are beasts as they are designed to self balance to a set value. now if the actuator and the sensor are attached to each other and controlled via a PID the whole system can swing like HELL. actually i burnt my first servo playing with the setup and was happy to learn that my humble mechanic design worked really well for maintainability…

i used mostly these links to understand how it works:

and lots of reading around this. the problem is that nobody can tell you how to tune your PID in your setup. so there’s a whole lot of trial and error with many strategies being published on how to find the right parameters. as you can see in the video, the parameters are sort of okay, but still the system is behaving a bit “choppy”. but if i react too often to the sensor values, the system starts to swing. so here’s some homework left and i hope that this blog post will spur some discussion in the forums. and there’s a nice blog post that obviously led to the PID library included in the arduino software distribution. i also want to learn from that.

let’s see the system in action:

finally, i also studied a bit how the bot walks with and without the gimbal active. the first part of the video shows it from front and top with the gimbal active, the second part shows it from top and side with a stiff upper body.

you can see that the upper body’s lateral amplitude is higher when switched off. this will be even more the case when we load the shoulders with a head and arms in the next iterations.

i will do another blog post investigating the gimbal effect more deeply. i just bough a tiny camera that i can attach to the neck and will tape trashbot from “first person perspective” :-)