Final Robotics Presentation

Jerry the Pet Snail

By: Sofia Shockman

The concept behind Jerry came about behind the Tamagotchi handheld game that I used to play as a kid. I actually owned the Littlest Pet shop one but it isn’t as common so I say Tamagotchi so people know which one I’m talking about. My initial design consisted of two sensors which were an ultrasonic and an rgb color sensor. I had measured the frequency so if the frequency was greater than 300, which was the green color, then it would turn on the light and shake his head indicating that he is hungry and will be charged.  Shortly after my computer crashed, I had realized that I needed to redo the code and try again with another sensor because it was very inconstant when I was reading data. That is when Rudy lent me his 2 wireless chargeable coils that came in perfectly and replaced the color sensor, which was intended to be my seaweed. For the seaweed, I sewed together some green felt and covered the wireless coil to disguise it. For the construction of the snail I was able to take the 3D shell and drill holes into the top that I could screw into the structure that Rudy lent me. (Shoutout to Rudy for lending me all the useful equipment that I couldn’t find in the lab).

Then I used the previous board that I had used for my prototype as a my main board and attached the coil sensor onto it. I later glued/taped on the ultrasonic sensor to the coil to the servo, which was creating Jerry’s face. Then I used a metal material to create the antennae and attach the face to the body structure of Jerry. That is how the building process went about.

I ran into a lot of complications along the way and it was a big jump during the whole course period, but it was rewarding to say that in the end I learned so much more than I could have ever imagined.

IMG_4573

#define trigPin 11
#define echopin 12



#include <Servo.h>

#define servoPin 9
#define coilPin A0

Servo myservo;

int pos= 0;

int speedPin_M1 = 5;     //M1 Speed Control
int speedPin_M2 = 6;     //M2 Speed Control
int directionPin_M1 = 4;     //M1 Direction Control
int directionPin_M2 = 7;     //M1 Direction Control


void setup() {
   myservo.attach(servoPin);
}



void loop() {


 int coilValue = analogRead(coilPin);

  if (coilValue > 200) {
    for (pos = 0; pos <= 90; pos += 1) { // goes from 0 degrees to 180 degrees
      // in steps of 1 degree
      myservo.write(pos);              // tell servo to go to position in variable 'pos'
      delay(15);                       // waits 15ms for the servo to reach the position
    }
    for (pos = 90; pos >= 0; pos -= 1) { // goes from 180 degrees to 0 degrees
      myservo.write(pos);              // tell servo to go to position in variable 'pos'
      delay(15);                       // waits 15ms for the servo to reach the position
    }
  }


  
  carAdvance(100, 100);
  delay(1000);
  carBack(100, 100);
  delay(1000);
  carTurnLeft(250, 250);
  delay(1000);
  carTurnRight(250, 250);
  delay(1000);
}

void carStop() {                //  Motor Stop
  digitalWrite(speedPin_M2, 0);
  digitalWrite(directionPin_M1, LOW);
  digitalWrite(speedPin_M1, 0);
  digitalWrite(directionPin_M2, LOW);
}
void carBack(int leftSpeed, int rightSpeed) {       //Move backward
  analogWrite (speedPin_M2, leftSpeed);             //PWM Speed Control
  digitalWrite(directionPin_M1, HIGH);
  analogWrite (speedPin_M1, rightSpeed);
  digitalWrite(directionPin_M2, HIGH);
}
void carAdvance(int leftSpeed, int rightSpeed) {     //Move forward
  analogWrite (speedPin_M2, leftSpeed);
  digitalWrite(directionPin_M1, LOW);
  analogWrite (speedPin_M1, rightSpeed);
  digitalWrite(directionPin_M2, LOW);
}
void carTurnLeft(int leftSpeed, int rightSpeed) {    //Turn Left
  analogWrite (speedPin_M2, leftSpeed);
  digitalWrite(directionPin_M1, LOW);
  analogWrite (speedPin_M1, rightSpeed);
  digitalWrite(directionPin_M2, HIGH);
}
void carTurnRight(int leftSpeed, int rightSpeed) {    //Turn Right
  analogWrite (speedPin_M2, leftSpeed);
  digitalWrite(directionPin_M1, HIGH);
  analogWrite (speedPin_M1, rightSpeed);
  digitalWrite(directionPin_M2, LOW);
}

Robotics_d6

The KinderBot

 

 

 

 

 

To summarize, my goal was to create and build a swarm of small Robot. That could emulate a combination of Roach and Lightingbug behaviors.  As of now, the robot does not fly! Well actually, flying was never a goal in this project; BUT THAT WOULD BE SUPER COOL.

KinderBot guts (Oct 25)

Software Diagram-

Mechanics Diagram-

 

Electronics Diagram-

 

The Design Process:

It is important to note that this robot hasn’t always looked like this…Or ar least its insides haven’t looked like above.

in fact, here is an image of the very first prototype.  The KinderEgg has survived through so much!

Version 1: the Concept(s)

During an early initial brainstorming session with Rudi. I came up with an idea of having multiple robots move in a vertical line across a surface while emitting a specific color of light. All while a camera with a long exposure image is taken with a nearby DSLR.  The final image from the DLSR would be presented the audience–“light painting .”

Similar Idea :

 

An Iteration later, we came to the conclusion that the bots were merely emulating a television. Although the TV is a great advancement in tech…having the basics of a television display, is pretty boring and could get old very fast.  While deciding that  TVs were boring, I began to wonder what would happen if I could take Long exposure images of other things. Like some nature and organic critters that may or may not exist in everyone’s homes.

 

eventually, the question became: how can make bugs beautiful without having to see them?

 

But how?

ThenI was hit by an idea!

{cue story}

Now it time to work!

Sensor Grab-Bag!

Version 1:Bugs and Chips

Naturally, i wanted my bots to be as small as possible. after a brief demo in Toy Design.  I was formally introduced to Nick ( IMA fellow) and the attiny85 ( tiny microcontroller).

Chat’s with Nick eventually inspired me to begin my search for parts small enough light enough propel a tiny robot.

Some projects that inspired:

PingBot

WinkBot

KiloBot

Version 1_A question of Locomotion: \

Q-How can we get such a small robot moving?
A-small motors. Specifically, tiny dc motors.

Locomotion can be achieved by having the shafts for each motor directly contact a surface. No need for wheels! #shoutouttoRudi

—different shaft designs for different environments; Motors with teeth ( gears) for improved traction.

—different motor entirely—Vibration motors

Version_1 Enter the Kinder:

After a long night if playing/crying with motion capture cameras. Bruce and I decided to treat ourselves to the only thing close and open past 10pm–FamilyMart.  Immediately, Purchased a Kinder egg–or Joy?– and had me a Eureka moment! “why not recycle materials more often?”

{Succes test of Motors + KinderBot close-up}

Version_1 Brainstorm :

–motors should only go in one direction( more on that soon) .

Verison_2 Only forward:

It turns out that having such small board means, very few pins will be available with a lot less memory. So the previous brainstorm session needed a patch, but I would need help with optimization (and soldering…)

Brainstorm w/Rudi

 

 

 

Verison_2 ATTINY85:

8kb of data to work.

_programing with a shield-sure!

_programming and having to disconnect everything—-noway

Another way?

resources:

Attiny85 dataSheet

 

Verison_3 Digistump and ATTINY85:

6 pins  6kb of data

Guidance Suggestion: ALWAYS prototype on a board you are comfortable  with .

Uno Prototyping:

Behavior ideas:

–Diagrams for UN0 and Version 4

 

     

 

Inspiration from UC Berkeley

2LDRs did not work for me.

 

Verison_5 Digitstump:

DataSheet 

https://s3.amazonaws.com/digistump-resources/…/97a1bb28_DigisparkSchematic.pdf

Installation Vid1

Installation Vid2

Installation Vid3

USB Charging! #shoutouttoRudi

The random Wrench!

Why are things so sensitive???

Perfboard ( more soldering)

resources:

perfboard-Howto

SolderingTut

 

Overall this project has been very challenging and rewarding. I am glad to have had as many resources as I had. Otherwise, I would have likely chosen a much simpler project. On that note, I am also glad that this project has been as complicated as it has been. I feel like I have grown my understanding of microcontrollers and their parts.

I certainly will continue working this project. In fat tiny robotics might be my new favorite thing. Below are some of the many takeaways and future features I want to add or re-add.

  • Solder more often.
  • jumping–small hangtime
  • IR sensing for rugged behavior
  • a fresh coat of paint.
  • PCB
  • and more

 

int speedPin_M1 = 5;     //M1 Speed Control
int speedPin_M2 = 6;     //M2 Speed Control
int buttonPressed;
int ledPin = 8;
int LDRarray[2];
int LDRspook = 100;


void setup() {
  Serial.begin(9600);
  pinMode(2, INPUT_PULLUP);
  pinMode(ledPin, OUTPUT);
}
void loop() {

  buttonPressed = digitalRead(2);

  if (buttonPressed == LOW ) {
    ledOn();
    carAdvance (100, 100);
    delay(1000);
  }
  else {
    ledOff();
    carStop();
  }

  for (int i = 0; i < 2; i++) {
    LDRarray[i] = analogRead(A0);
    Serial.println("hello");
    delay(1500);
    int N_delta =  abs(LDRarray[0] - LDRarray[1]);
    Serial.println(LDRarray[0]);
    Serial.println(LDRarray[1]);
    Serial.println(N_delta);
    //    delay(700)

  }

  if ( abs(LDRarray[0] - LDRarray[1]) > LDRspook) {
    carAdvance(200, 200);
    delay(3500);
    Serial.println("madspooks");
  }


  if (LDRarray[0] || LDRarray[1] <= 200) {
    ledOn();
    delay(50);
    Serial.println("LEDon");
    //    Serial.println(ldrStatus);
  }
  else {
    ledOff();
    delay(50);
    Serial.println("LEDoff");
    //    Serial.println(ldrStatus);
  }
  //

}
void carAdvance(int leftSpeed, int rightSpeed) {     //Move forward
  analogWrite (speedPin_M2, leftSpeed);
  analogWrite (speedPin_M1, rightSpeed);
}
void carStop() {                //  Motor Stop
  digitalWrite(speedPin_M1, 0);
  digitalWrite(speedPin_M2, 0);
}
void ledOn() {
  digitalWrite(ledPin, HIGH);
}
void ledOff() {
  digitalWrite(ledPin, LOW);
}


Deliverable 6: Final Project

Project Name: DJ Robot

Project Description:Generally, the robot will have different movements under the certain melodies. After several times’ modifications and adjustments, I finally changed my project into this way. Before, I was trying to let the robot follow the lines or some certain tracks and detect the “RFID” sensors to add tracks to a music. But when I actually tried different sensors and combined them together, I found out that my previous ideas are too ideal. When I used Bluetooth to connect Arduino and Processing, I found out that it took a really long time for Processing to react, and sometimes Processing can’t have certain reactions as expected. So it is kind of impossible for the robot to play music file while moving on the line. And when I tried to use light sensors to control the robot movements, it is very hard to control the robot and the “gameplay” for the project is not very good. So I reconsidered and decided to change a little. The final version of the project is: when using RFID tags scan the robot, the robot will play a certain melody and have a specific movement, and the melodies are accumulated, which means it won’t stop if other tags scan the robot, at last, it will become a song. Also, users can use light to control the speed of the robot’s movements.   Continue reading

#include <SoftwareSerial.h>
SoftwareSerial mySerial(2, 3);
#define BT_SERIAL_RX 8
#define BT_SERIAL_TX 9
SoftwareSerial BluetoothSerial(BT_SERIAL_RX, BT_SERIAL_TX);
int speedPin_M1 = 5;     //M1 Speed Control
int speedPin_M2 = 6;     //M2 Speed Control
int directionPin_M1 = 4;     //M1 Direction Control
int directionPin_M2 = 7;     //M1 Direction Control
int Speed; //map speed with brightness
const int LDR = A0;

int inByte = 0;         // incoming serial byte
void setup() {
  // put your setup code here, to run once:
  int i;
  for (i = 6; i <= 9; i++);
  pinMode(i, OUTPUT);
  BluetoothSerial.begin(9600);
  //BluetoothSerial.println("Where are you");
  mySerial.begin(9600);
  Serial.begin(9600);
}

void loop() {
  byte i = 0;
  byte val = 0;
  byte code[6];
  byte checksum = 0;
  byte bytesread = 0;
  byte tempbyte = 0;
  int light = analogRead(LDR);
  Speed = map(light, 20, 550, 80, 200);
  // put your main code here, to run repeatedly:
  if (mySerial.available() > 0) {
    if ((val = mySerial.read()) == 2) {                 // check for header
      bytesread = 0;
      while (bytesread < 12) {                        // read 10 digit code + 2 digit checksum
        if ( mySerial.available() > 0) {
          val = mySerial.read();
          if ((val == 0x0D) || (val == 0x0A) || (val == 0x03) || (val == 0x02)) { // if header or stop bytes before the 10 digit reading
            break;                                    // stop reading
          }

          // Do Ascii/Hex conversion:
          if ((val >= '0') && (val <= '9')) {
            val = val - '0';
          } else if ((val >= 'A') && (val <= 'F')) {
            val = 10 + val - 'A';
          }

          // Every two hex-digits, add byte to code:
          if (bytesread & 1 == 1) {
            // make some space for this hex-digit by
            // shifting the previous hex-digit with 4 bits to the left:
            code[bytesread >> 1] = (val | (tempbyte << 4));

            if (bytesread >> 1 != 5) {                // If we're at the checksum byte,
              checksum ^= code[bytesread >> 1];       // Calculate the checksum... (XOR)
            };
          } else {
            tempbyte = val;                           // Store the first hex digit first...
          };

          bytesread++;                                // ready to read next digit
        }
      }
    }
  }
  //if (BluetoothSerial.available() > 0) {
  // get incoming byte:
  // inByte = Serial.read();
  // Output to Serial:

  // Serial.println(checksum);

  if (checksum == 183)
  {
    BluetoothSerial.println("A");
    //delay(100);
    carAdvance(Speed, Speed);
    delay(1000);
    carBack(Speed, Speed);
    delay(1000);
  }
  if (checksum == 85)
  {
    BluetoothSerial.println("B");
    //delay(100);
    carTurnLeft(Speed, Speed);
    delay(1500);
    carTurnRight(Speed, Speed);
    delay(1500);
  }
  if (checksum == 6)
  {
    BluetoothSerial.println("C");
    //delay(100);
    carAdvance(Speed, Speed);
    delay(1500);
    carBack(Speed, Speed);
    delay(1500);
    carTurnLeft(Speed, Speed);
    delay(1500);
    carTurnRight(Speed, Speed);
    delay(1500);
  }
  if (checksum == 131)
  {
    BluetoothSerial.println("D");
    //delay(100);
    carAdvance(Speed, Speed);
    delay(1000);
    carTurnLeft(0, Speed);
    delay(1500);
    carAdvance(Speed, Speed);
    delay(1000);
    carTurnRight(Speed, 0);
    delay(1500);
    carStop();
  }
  //Blue
  if (checksum == 129)
  {
    BluetoothSerial.println("E");
    //delay(100);
    carAdvance(Speed, Speed);
    delay(2000);
    carBack(Speed, Speed);
    delay(1000);
    carAdvance(Speed, Speed);
    delay(1000);
    carBack(Speed, Speed);
    delay(2000);
  }
  //Yellow
  if (checksum == 221)
  {
    BluetoothSerial.println("F");
    //delay(100);
    carTurnRight(Speed, 0);
    delay(1500);
    carBack(Speed, Speed);
    delay(1000);
    carTurnLeft(0, Speed);
    delay(1500);
    carBack(Speed, Speed);
    delay(1000);
  }
  //Red
  if (checksum == 219)
  {
    BluetoothSerial.println("G");
    carAdvance(Speed, Speed);
    delay(1500);
    carBack(Speed, Speed);
    delay(1500);
    carTurnLeft(Speed, Speed);
    delay(1500);
    carTurnRight(Speed, Speed);
    delay(1500);
    bytesread = 0;
  }
  else {
    carStop();
  }
  delay(100);

}

void carStop() {                //  Motor Stop
  digitalWrite(speedPin_M2, 0);
  digitalWrite(directionPin_M1, LOW);
  digitalWrite(speedPin_M1, 0);
  digitalWrite(directionPin_M2, LOW);
}
void carBack(int leftSpeed, int rightSpeed) {       //Move backward
  analogWrite (speedPin_M2, leftSpeed);             //PWM Speed Control
  digitalWrite(directionPin_M1, HIGH);
  analogWrite (speedPin_M1, rightSpeed);
  digitalWrite(directionPin_M2, HIGH);
}
void carAdvance(int leftSpeed, int rightSpeed) {     //Move forward
  analogWrite (speedPin_M2, leftSpeed);
  digitalWrite(directionPin_M1, LOW);
  analogWrite (speedPin_M1, rightSpeed);
  digitalWrite(directionPin_M2, LOW);
}
void carTurnLeft(int leftSpeed, int rightSpeed) {    //Turn Left
  analogWrite (speedPin_M2, leftSpeed);
  digitalWrite(directionPin_M1, HIGH);
  analogWrite (speedPin_M1, rightSpeed);
  digitalWrite(directionPin_M2, LOW);
}
void carTurnRight(int leftSpeed, int rightSpeed) {    //Turn Right
  analogWrite (speedPin_M2, leftSpeed);
  digitalWrite(directionPin_M1, LOW);
  analogWrite (speedPin_M1, rightSpeed);
  digitalWrite(directionPin_M2, HIGH);
}

Deliverable 5: Final Update

Final Project Description: Generally, It is a DJ Robot. It’s a Robot dancing and adding different tracks of music at the same time. I will put different RFID cards at different locations, and I will provide many black line people can design their own tracks to connect RFID cards together, people can choose which cards and how many cards they want to choose, People don’t have to choose all the cards.  Continue reading

Deliverable 5:-)

Jerry the Snail- loves to eat and sleep–sounds relatable

For ages 8-80 years old

For my final robot, I want to create a pet snail that assimilates a real snail by capturing the actions of an actual snail. I took a look at some snail videos to try to observe what they do and how they go about their day and it was really interesting and really helpful to integrate into the concept and execution of my project. From the videos I saw on Youtube they are very slow creatures who have nothing else on their agenda but to eat.

I began by designing the shell of my snail which is a classic snail design. I was struggling in the labs to get it just right because of complications but I went to talk to Rudi and felt reassured to go for it and to not take no for an answer. Upon completing the 3D printing of my shell I decided to begin with the baseboard of the pet. I kept the bottom a simple structure and attached 4 wheels with traction, 4 DC motors, a mini servo, and batteries. I then covered it with a cloth to make it look like the body of a snail. The sensors I have used are ultrasound to measure the distance and to make sure he does not run into a wall or an object about 15 cm in front of it, an infrared sensor with LED lights to detect his environment, and a color sensor to detect a piece of lettuce as he moves closer to about 10 cm in front of him.

When testing, I was able to have Jerry move back and forth and detect his environment. He is slow and steady, but hey slow and steady wins the race!! He also reacts to the lights being turned off and on because of the infrared sensors. The only problem I ran into was placing all the hardware inside of Jerry and also figuring out the color sensor and how he eats lettuce, but I’m not giving up and Jerry will soon have his meal of delicious greens.

Robotics_Deliverable5

 

Detailed Documentation: lucibufagens ( working title)

I want to begin with that feeling most people get when they see some thing out of the corner of your eye. In particular something small dark, fast and close to the ground. I often compare that feeling to anxiousness and phobia. Your body stiffens-up your brain is are on alert, expecting the worst. Out of the corner of your other eye, zooms the little spec into plain sight! Heart rates skyrocket!

I find it interesting that a large percentage of people fear pests or creepy-crawlies in some what or another. A close friend has a very low a tolerance for creepy crawlies—Ants in particular.  Ants simply freak my friend out. So much so that the presence of an ant will cause them to evacuate the room until the pest is disposed of –ideally in a humane or non-harming manner.

But why are people frightened by these tiny creatures? First hand experience, texture, structure, or even psychological cues? I am not sure why.  Personally, I never found them to be very frightening, but every so and then; especially when its dark—BAM—my heart begins to pound!

On a different note, I find the bioluminescence from fireflies to be aw-inspiring. Up until recently,  I never actually experienced a firefly in real life. I had no idea they where actually a species of beetles. I was blown away when I saw them in person.  The very first time I saw one, I immediately wanted to hold one, I was so drawn-in. There was a moment in particular after I had reached out to catch one, where I realized that I was getting nervous was experiencing the very same sensation on gets when they see a creepy crawly. Thus I panicked and the bug flew away.

How is it that one can be attracted and yet terrified by a tiny light in the dark?

My friend would say that I found beauty in something unpleasant.

This project hopes to further illustrate the sensation I got when interacting with the fireflies. By creating a robotic installation mimicking the behaviors of common household bugs.

By creating a swarm tiny robots. I hope to replicate the common phobia of creepy-crawlies. At the same time I hope to use the swarm (or colony ) to reveal the inserting paths and strides the swarm builds.  I hope to do so by equip each bug with a smart LED that will emit its designated color at certain times in order to emulate different pixels in an image.  Duing the run time, a long exposure photograph  will capture the “light paintings” the bug-bots create. Perhaps we will find beauty in these pests.

[edits to be added]

Constrains:

Size- for this project to fully emulate bugs,each bot will need to be as small as possible. I don’t think the same effects will occur with large bots.

Power-Powering such a small device will be rather difficult. Chips like the attiny can only handle 5V.

Memory-Programming on a attiny85 will be difficult due to the fact the chip can only hold ~~8 KB  of program, Thus the program will have to be as efficient as possible.

–unexplored territory

List of Parts

Bot

Attiny85

-attiny programing shield (Nick has built a custom one)

-attiny prototyping USB

Sensors and electronics

-Light sensor ( scatter effect, similar to roaches)

-IRC ( Distance/ bug identifier) ßà Ultrasonic ranger ßà flexie meter( bumper car style)

-Bluetooth module (control: as simple as start and stop)

-smartLED ( luminescence )

-tiny motors ( locomotion)

Installation:

-Webcam

-Tripod

-DSLR

-dim room

 

Some Documentation:

{ i forgot to pick-up jumper cables…}

 

Freshly soldered “kinderBot” ( with motors, jumper cables and hot glue..ty Rudi)

 

AttinyShields and Attiny

attiny close-up ( finger in frame for scale comparison)

 

Sensors: Bluetooth,IR,Ultrasonic

 

 

 

Video: Nick and I had a programming session. Very informative.

 

 

 

 

 

Rough Software Diagrams and Notes

 

 

 

Assignment 6

When I did a google search for bio-inspired robots I came across Harvard University’s first autonomous entirely soft robot. It is powered by a chemical reaction controlled by microfluidics and has no electronics. The project began at the Harvard school of engineering in 2016 when a group of researchers came together to give soft robotics a try. I found it very interesting because it is the beginning of what could be the future of replacing hardware and rigid boards and batteries for robots that are entirely soft. The octobot contains fuel storage and is powered by gas under pressure. It has the same amount of dexterity as an actual octopus and can perform similar movements. Inside the octobot is liquid fuel (hydrogen peroxide) which transforms which transforms into a large amount of gas that flows into octobots arms and inflates them.  All it takes is soft lithography, molding, and 3D printing. It may not perform many tasks but it assimilates an octopus physically and internally with no hard or rigid components. I think this is cool to note that this is the future and that hardware has the potential to be soft and to fully embrace the versatility as if it weren’t a robot anymore.

Robotics_Assignment6

Robotic-Fish

Initial research in 1989 with the robo-tuna by MIT.

https://en.wikipedia.org/wiki/RoboTuna

Made to imitate the locomotion of actual fish using Body-Caudal Fin Propulsion. There have been hundreds of articles on robotic fish.  Only a few research projects have been capable of full movement.

Initial projects primarily studied locomotion. In contrast, today most research efforts have been toward controlling behaviors, such as communication and navigation.

Quick images search:

https://www.google.com.hk/search?q=robotic+fish&tbm=isch&tbo=u&source=univ&sa=X&ved=0ahUKEwiB-sytwvPWAhUGn5QKHU9RCCAQ7AkIPw#imgrc=2wejvtIzecHSSM

 

http://www.robotic-fish.net/

Advances and uses outside of research:

Environmental sensing and exploration

https://www.sciencedaily.com/releases/2017/05/170510091553.htm

https://www.roboshoal.com/

https://www.designboom.com/technology/pollution-detecting-robotic-fish/

Many levels of fidelity with the Robo-fish:

https://www.wereblog.com/japanese-invents-life-like-robotic-fish

Robot fish in Maihama Tokyo Bay-

https://www.youtube.com/watch?v=wiK5fxV7ycI

Fish with lasers in South Korea

https://www.youtube.com/watch?v=-wBJPKiaxyg

Advancements at MIT

http://news.mit.edu/2014/soft-robotic-fish-moves-like-the-real-thing-0313

Robot fish toy

https://www.youtube.com/watch?v=31E8ywyUCrw

Robotics_concept_testing

For my final, I intend to create a proto-swarm of small robots. Ideally, the bots are to be as small as possible; perhaps smaller than 10cm^3  per bot.  Creating such a small “creatures” will prove to be very challenging–all while simulating insect behaviors.

To quickly summarize,: observers will be given to the opportunity to see the natural beauty that are swarms of insects. Via purposeful movements and group communication, the swarm is to explore a dark terrain which will then be mapped out( with the help of on-board smart LEDs) via long exposure photography-or “light paintings”. A keen eye might notice that the paintings will represent an image of some kind. Whether pre-determined images or live footage is to be determined at this stage.

After bouncing a few ideas around with IMA fellow Nick we came to the conclusion that an ATtiny board. We noted a few disadvantages: low power and low memory. Efficiency will be a major design factor!

Locomotion became another hot topic, as ATtiny boards are not capable of delivering enough power for wheels with high friction coefficients

The idea of having vibration motors was considered as a workaround, however, stability and controllability became a  major concern.

 

Rudi and I spoke about many issues these bots could have as well as many insights as to how to approach the bots as efficiently as possible. More on that soon.

as for locomotion.

Tiny DC motors became a worthy solution item -using their shafts to directly propel the bot.

On to testing.

Rough motor placements–


Actual test with super light chassis–this is also one the most annoying things I have ever made.

All seems to work, it is a matter of motor angles and wire connection. Further testing with different chassis are a must.

 

Pintbot, Winkbot, Kilobot and a few others are a few robots that have similar hardware. Most prominently the motor shaft to ground solution for locomotion.