Pursuits of Design and Robotics

The documentation of concept development and general processes


Leave a comment

Sketch Helper: Precedents, Ideas, Goals.

There are a couple of projects that were really inspiring to me as drawing aids. The first being from a Carnegie Mellon student from Computation Design years ago, Sketch it, Make it, which is now called Zotebook. The app allows you to draw quickly on your tablet and it offers corrections and perfections as you go.

What is particularly nice about this application is that it can be output straight to a 3d-printer or laser-cutter to create quick models that were drawn up in minutes. Very useful and accurate way to ‘sketch’ prototypes and have them realized immediately.

Another precedent to look at is the NeoLucida which incidentally was also started by someone who was at CMU, Pablo Garcia. The NeoLucida is essentially a lucida with some electronics involved. It allows the user to trace the reality that the user sees through the lucida as it is projected, in a way, on to the paper.

This project is great for its unobtrusiveness in the analog process. It does not limit the user, as it can only provide visual suggestion. I think this could help a lot in how I think about how my application will aid the drawing process.

People today are relying quite heavily on the aid of technology and in my opinion it is losing people the touch of the hand, the personal quality of mistakes, imperfections, and personality. This feels especially true in renderings of architecture, as the goal is to be realistic but in being so all images to me look like they could be made by the same person, nothing really stands out. I think it’s valuable to add personal flair to an image. In the style of the drawing, through the personal touch. Even when this is not the case, when the drawer is simply trying to quickly output a sketch for an idea, when using technology the image tends to come out very complete-looking. The common thought about this is that completed and accurate drawings look resolved and thus makes the conceptual idea being communicated uninviting to critiqued by clients or peers because it seems resolved. This is a real issue in the world of HCI, for example, when it comes to sketching user interfaces and testing them with surveys. The surveyor will feel inclined to say less if the tested product is more complete or finalized looking.

Essentially then, what feels necessary that seems missing in the technologically aided drawing world is something that provides the efficiency that drew people into the digital drawing world, while maintaining the hand-drawn sketch feeling that can only be provided by the old fashioned pen-and-paper method. My idea is to make that happen using the Equill pen and combining it with another technology, which I’m currently considering to be either a screen or a projector.

This is what I had had up until a short while ago, using the Surface Pro 3 and its pen with the tip replaced by a piece of graphite. As you can see in the second video there are plenty of comments to be made on how it can be improved.

In addition to Rohan’s comments in the video, I’ve also come to the conclusion that there should also be a small space designated to construction drawing. As you saw, Rohan even drew a smaller version of what he was to draw. It is common in perspective drawings to first draw a floor plan and the viewpoint and viewing angle. I could use that basic plan and possibly an additional section to automatically construct the room for the user.

Because that could be complicated and not quite intuitive for a beginner, I’m also considering having the option for a default scaffolding that can be navigated through and have the view be selected before beginning the drawing process. This option allows for a building off of the scaffold, which could inspire ideas and be easier to start from than nothing.

I think both can be done. I am currently tapping into the Equill Pen SDK and trying to figure out how to take advantage of all of its features. I am hoping to move completely away from the Surface Pen because it is obviously limited to itself, while the Equill can work on multiple platforms.

Advertisements


Leave a comment

Sketch Helper

Pen with graphite tip replacing the plastic one it comes with

img20

SketchHelper is an app that aids in the analog perspective sketching process. The idea is that the artist can use the application to provide on-the-go construction lines. Currently the design of the interface is static and not technically optimal; there is much left to be done in this project and for this reason it will be continued next semester with a lot of surveys, user-testing, and design upgrades based on the advice.

SketchHelper speaks to the growing world of intelligent machine-aids in analog processes. The interest to these kinds of process designs is to create potential for the quick and intuitive methods of making that people are capable of responding to in the living world, in real time, to incorporate efficiency and insight and thus allow the designer to create things, and in ways, that might not have been possible before. By doing the tedious work for the designer and intelligently responding to the designers gestural habits, this application will become embedded into the processes that designers are already familiar with. I envision the work to be analogous to a calculator in the math world, there to make math easier but not to replace the person’s thought process.

The first video shows the app in use at high speed. The second video shows someone who was newly introduced to the application at that instant and providing what I considered to be extremely insightful feedback, and communicates the direction that I intend on going as I continue this project.


Leave a comment

Smart 3D Pen Research

“FreeD” by Amit Zoran. 2013

More

Amit references

“Haptic Intelligentsia” by Joong Han Lee. 2012

More

Amit uses magnets for 3D tracking. I found this website that appears to be a DIY. Maybe I can work on this for another project if the Leap works.

I was worried it wouldn’t so I did a lot of research on 3D magnet tracking, which is still an option maybe…maybe I’ll save it for another project. I’ll post some links just so people can see what I was thinking about if you’re interested.

DIY Magnet Tracker Sites
1 2 3 4 5

 Understanding the limitations of the pen. Make sure it can work with how I want to use it.

Understanding the limitations of the pen. Make sure it can work with how I want to use it.

THE LEAP WORKS!

Pen over Leap


Leave a comment

Independent Study

My independent study is going to be a continuation of my project for the embedded wearable technology in Ali Momeni’s Hybrid Instruments course.

I want to make my cat bowl smart enough to determine what cat is approaching it, whether it should let the cat eat, how much, and how many times through out the day. The bowl will relay information to me through a phone application. With the app I can see how many times each of my cats tried to eat today, what cat interrupted what cat from eating, how much the cats ate so far today, and I can control everything.

I found a few precedent examples of people who have thought about this, but I don’t think anybody did it as well as I will do it.

http://gatefeeder.com/

Gatefeeder is decently designed, the door is clever for not needing a servo and having the cat open the door. The inset depth of the door is presumably to prevent a second cat from pushing his head in and keeping the door open for himself to eat. I could consider a design that accomplishes similar results. Gatefeeder is doing a lot of what I want except that it doesn’t differentiate between cats and it is not intelligently learning about the cat’s behavior. Actually, there are no cat bowls that actually monitor the feeding. They only open and close.

http://petsweekly.com/en/all-about-cats/cat-health/cat-behavior/663-feeding-individual-diets-in-multi-cat-households

This website shows some other examples of cat feeders, mainly SureFlap and Meow Space. Both use the idea of a cat-door to a confined space to allow certain cats in to eat. Again, these lack control over how much is eaten by different cats who have access to the same bowl.

The precedents are there and it’s reassuring to see that there are no data-interpreting bowls like I intend to make, but the bowls are similar enough to help me understand the best actuation methods. RFID was the right way to go, yay!

I have ordered online an RFID reader component and an antenna for it to allow a range of up to 3 feet. This way if one cat tries to sneak up on the one eating, the bowl will just shut down and they’ll have to give up on eating at the same time. I also got tags that should be perfect for the collar.


Leave a comment

Enchanted Object: “SoapBox: Lonely Dog Up For Adoption” by Priya Granadas and Yeliz Karadayi

SoapBox: Lonely dog up for adoption from Priya Ganadas on Vimeo.

SoapBox is a puppy who likes pretending he goes on adventures though really he just likes to sit on his couch. SoapBox is lonely and looking for love, however, if you hit him he will like you less and less. He is forgiving though, of course, and if you hold your hand out to him gently and wait to pet him, you might win him over and he’ll reach back out for your love. He gets confused when you disappear out of view, and he gets bummed when he’s alone. Voice reactions indicate his mood, and he moves when he’s reaching out for you to pet him. SoapBox wants to learn to love!

Alone Soap sits, waiting for someone to love

Alone Soap sits, waiting for someone to love

Could it be? Will somebody take me?

Could it be? Will somebody take me?

Alas, no. I continue to sit here sobbing on my SoapBox.

Alas, no. I continue to sit here sobbing on my SoapBox.

 


Leave a comment

Sing To Me Physical Process

The first model of the flower was too stiff for the servo to work. Also the box was ugly. I did really like the idea of wood, though, because of the warm ambiance it gives off. I thought the ribbons might look nice but they look terrible and desperate. The flower was too big to get a lot of movement out of a small servo, and I hadn’t considered until after seeing this that the string should not be out in the open like that all the way down to the base. There should be some kind of protection.

I redid it to make it look a bit more planned and smooth. See the final product in the final post for this.

Elevation view, closed.

Elevation view, closed.

No hardware could fit down here. I did not plan well.

No hardware could fit down here. I did not plan well.

Flower Opened

Flower Opened

Flower Closed

Flower Closed


Leave a comment

SoapBox Code

Well, this code kicked my face. But I think I got it. 

Let’s start with the obvious information: I have a distance sensor, and I have a servo. When the distance provides some desired information, Soap will return a desired output. I start with smoothing, because I’m starting to think everything should always be smoothed, at least a little, for better results. After I smooth, I track. I track by putting the smoothed distance values in an array for 10 frames [so trackingArray.length = 10] which is no time at all, but better than tracking for seconds, meaning high tolerances, and thus lower reflexes. So the dog tracks your movement for 10 frames which is probably around a second. Then the dog runs some tests on this information. If you mass addition the differences between the distances from one frame to the next, the result will yield whether or not you are approaching the dog or distancing from it. This result also tells you, on average for the past 10 frames, how fast the movement was as well. 

Additionally there are factors such as slow movement while being close to the dog versus fast movement far away from the dog, and so on. My favorite aspect of this puppy, though, is that he knows if you are hitting him, and he gets upset with you. For every frame that the dog interprets your movements as a hit, he will become jaded and less friendly to your approach. If you patiently hover your hand slowly to him, however, he will grow to like you again.

I was pretty proud of this code for a first project. Priya and I faced a lot of struggles in dealing with the COM Port communicating while the servo was plugged in, which I learned today [also known as too late] was the fault of the cable I was using to load the code to the Arduino. Additionally, we also struggled heavily with the sound output which Priya took charge of and failed after I failed first. We still don’t know why that didn’t work. It worked on all of the example files, but not on ours. However I know the rest of the code works due to the most lovely Serial.println function.

So, all you need is a Servo and a distance sensor and this disastrous code will tell you what’s up.

#include <Servo.h>
//orange to ground
//red to 24
//green outputs 24
Servo arms;
Servo head;

int distThresh = 600;
int soundThresh = 600;

int distSensor = 0;
int microphone = 1;

int armsPin = 9;
int headPin = 10;

int const smootheFC = 3;
int thisSmooth = 0;
int smoother[smootheFC];
int average;
int total;

int const trackFC = 10;
int thisFrame = 0;
int trackMovement[trackFC];

int frameCounter= 0;
int timeToMove = 1000;
int averageGen = 0;

int const stateCount = 5;
int stateIndex = 0;
int states= 0;
int saveStates[stateCount];

void setup()
{
arms.attach(armsPin);
pinMode(7, OUTPUT);
pinMode(distSensor, INPUT);

Serial.begin(57600);

for(int i = 0; i < smootheFC; i++){
//smoothes
smoother[i] = 0;
}
}

void loop() {

frameCounter ++;
int distance = analogRead(distSensor);
averageGen = 0;

if (frameCounter == timeToMove){
// Serial.println(thisSmooth);

total = total – smoother[thisSmooth];
smoother[thisSmooth] = distance;
total = total + smoother[thisSmooth];
thisSmooth ++;

if (thisSmooth >= smootheFC)
{
// Serial.println(“thisSmooth = 0”);
thisSmooth = 0;
}

Serial.print(“[“);
for(int i = 0; i < trackFC-1; i++){

Serial.print(trackMovement[i]);
Serial.print(“, “);
}

Serial.println(“]”);

average = total / smootheFC;

for(int i = trackFC -1; i > 0; i–)
{
trackMovement[i] = trackMovement[i-1];
trackMovement[0] = average;
}

for(int i = 0; i < trackFC-1; i++) averageGen += (trackMovement[i+1] – trackMovement[i]);

int score = 0;
boolean sameState = false;

for(int i = 0; i < stateCount-1; i++)
{
if (saveStates[i] == saveStates[i-1]) score++;
if (score > 2) {
sameState = true;
Serial.println(“^” );
}
}

Serial.println(averageGen );
if ((averageGen <= -400) && (trackMovement[trackFC-1] != 0))
{
states = 4;
timeToMove = 2000;
Serial.println(“DON’T HIT ME!!!” );
arms.write(0);
}
else if (average < 200 && averageGen < 50 && averageGen > -50 )
{

states = 0;
timeToMove = 1000;
Serial.println(“Guess I’m alone!” );

arms.write(0);
}
else if (average > distThresh && averageGen < 50 && averageGen > -50)
{
states = 1;
timeToMove = 3000;
Serial.println(“PET ME!” );
arms.write(120);
}
else if ((averageGen <= 0) && (averageGen > -200))
{
states = 2;
timeToMove = 1000;
Serial.println(“you are getting closerclosercloser to me!” );
}
else if ((averageGen >= 0) && (averageGen < 200))
{
states = 3;
timeToMove = 2000;
Serial.println(“you are getting farther from me!”);
}
else if (averageGen >= 400)
{
states = 5;
timeToMove = 5000;
Serial.println(“WHERE DID YOU GO!?”);
}
Serial.write(states);

saveStates[stateIndex] = states;
stateIndex++;
if (stateIndex == stateCount) stateIndex = 0;

frameCounter = 0;
}
}